github-to-mcp-monorepo 1.0.0

package/packages/core/src/__tests__/redis-cache.test.ts

@@ -0,0 +1,307 @@
+/**
+ * @fileoverview Unit tests for Redis cache implementation
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { RedisCache, createRedisCache, RedisClientInterface } from '../cache/redis-cache';
+import { createCacheEntry } from '../cache/cache-interface';
+
+// Mock Redis client
+function createMockRedisClient(): RedisClientInterface {
+  const store = new Map<string, string>();
+
+  return {
+    get: vi.fn(async (key: string) => store.get(key) || null),
+    set: vi.fn(async (key: string, value: string) => {
+      store.set(key, value);
+      return 'OK';
+    }),
+    del: vi.fn(async (key: string | string[]) => {
+      const keys = Array.isArray(key) ? key : [key];
+      let count = 0;
+      for (const k of keys) {
+        if (store.delete(k)) count++;
+      }
+      return count;
+    }),
+    keys: vi.fn(async (pattern: string) => {
+      const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+      return Array.from(store.keys()).filter(k => regex.test(k));
+    }),
+    exists: vi.fn(async (key: string | string[]) => {
+      const keys = Array.isArray(key) ? key : [key];
+      return keys.filter(k => store.has(k)).length;
+    }),
+    mget: vi.fn(async (...keys: string[]) => keys.map(k => store.get(k) || null)),
+    mset: vi.fn(async (...keysAndValues: string[]) => {
+      for (let i = 0; i < keysAndValues.length; i += 2) {
+        store.set(keysAndValues[i], keysAndValues[i + 1]);
+      }
+      return 'OK';
+    }),
+    quit: vi.fn(async () => 'OK'),
+    dbsize: vi.fn(async () => store.size),
+    info: vi.fn(async () => 'used_memory:1024')
+  };
+}
+
+describe('RedisCache', () => {
+  let mockClient: RedisClientInterface;
+  let cache: RedisCache;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockClient = createMockRedisClient();
+    cache = new RedisCache({
+      client: mockClient,
+      keyPrefix: 'test-cache',
+      defaultTTL: 3600
+    });
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('get', () => {
+    it('should return null for non-existent key', async () => {
+      const result = await cache.get('nonexistent');
+      expect(result).toBeNull();
+    });
+
+    it('should return cached value', async () => {
+      const entry = createCacheEntry({ name: 'test' }, 3600);
+      await cache.set('test-key', entry);
+
+      const result = await cache.get<{ name: string }>('test-key');
+
+      expect(result).not.toBeNull();
+      expect(result?.data.name).toBe('test');
+    });
+
+    it('should return null for expired entries', async () => {
+      const expiredEntry = {
+        data: { name: 'expired' },
+        timestamp: Date.now() - 10000000, // 10000 seconds ago
+        ttl: 1 // 1 second TTL
+      };
+
+      // Manually set expired entry
+      await mockClient.set('test-cache:expired-key', JSON.stringify(expiredEntry));
+
+      const result = await cache.get('expired-key');
+
+      expect(result).toBeNull();
+    });
+
+    it('should track cache misses', async () => {
+      await cache.get('miss1');
+      await cache.get('miss2');
+
+      const stats = await cache.getStats();
+
+      expect(stats.misses).toBe(2);
+    });
+
+    it('should track cache hits', async () => {
+      const entry = createCacheEntry({ name: 'test' }, 3600);
+      await cache.set('test-key', entry);
+
+      await cache.get('test-key');
+      await cache.get('test-key');
+
+      const stats = await cache.getStats();
+
+      expect(stats.hits).toBe(2);
+    });
+  });
+
+  describe('set', () => {
+    it('should store value with TTL', async () => {
+      const entry = createCacheEntry({ name: 'test' }, 3600);
+
+      await cache.set('test-key', entry);
+
+      expect(mockClient.set).toHaveBeenCalledWith(
+        'test-cache:test-key',
+        expect.any(String),
+        'EX',
+        expect.any(Number)
+      );
+    });
+
+    it('should apply stale-while-revalidate tolerance', async () => {
+      const cacheWithSWR = new RedisCache({
+        client: mockClient,
+        keyPrefix: 'swr-cache',
+        staleWhileRevalidate: true,
+        staleTolerance: 3
+      });
+
+      const entry = createCacheEntry({ name: 'test' }, 100);
+      await cacheWithSWR.set('test-key', entry);
+
+      // TTL should be 100 * 3 = 300 seconds
+      expect(mockClient.set).toHaveBeenCalledWith(
+        'swr-cache:test-key',
+        expect.any(String),
+        'EX',
+        300
+      );
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete cached value', async () => {
+      const entry = createCacheEntry({ name: 'test' }, 3600);
+      await cache.set('test-key', entry);
+
+      await cache.delete('test-key');
+
+      expect(mockClient.del).toHaveBeenCalledWith('test-cache:test-key');
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear all values with prefix', async () => {
+      const entry = createCacheEntry({ name: 'test' }, 3600);
+      await cache.set('key1', entry);
+      await cache.set('key2', entry);
+      await cache.set('key3', entry);
+
+      await cache.clear();
+
+      expect(mockClient.keys).toHaveBeenCalledWith('test-cache:*');
+    });
+
+    it('should reset stats on clear', async () => {
+      await cache.get('miss'); // Create a miss
+      await cache.clear();
+
+      const stats = await cache.getStats();
+
+      expect(stats.misses).toBe(0);
+      expect(stats.hits).toBe(0);
+    });
+  });
+
+  describe('has', () => {
+    it('should return true for existing key', async () => {
+      const entry = createCacheEntry({ name: 'test' }, 3600);
+      await cache.set('test-key', entry);
+
+      const exists = await cache.has('test-key');
+
+      expect(exists).toBe(true);
+    });
+
+    it('should return false for non-existent key', async () => {
+      const exists = await cache.has('nonexistent');
+
+      expect(exists).toBe(false);
+    });
+  });
+
+  describe('getMany', () => {
+    it('should get multiple values at once', async () => {
+      const entry1 = createCacheEntry({ name: 'test1' }, 3600);
+      const entry2 = createCacheEntry({ name: 'test2' }, 3600);
+
+      await cache.set('key1', entry1);
+      await cache.set('key2', entry2);
+
+      const results = await cache.getMany<{ name: string }>(['key1', 'key2', 'key3']);
+
+      expect(results.size).toBe(3);
+      expect(results.get('key1')?.data.name).toBe('test1');
+      expect(results.get('key2')?.data.name).toBe('test2');
+      expect(results.get('key3')).toBeNull();
+    });
+
+    it('should handle empty keys array', async () => {
+      const results = await cache.getMany([]);
+
+      expect(results.size).toBe(0);
+    });
+  });
+
+  describe('setMany', () => {
+    it('should set multiple values at once', async () => {
+      const entries = new Map([
+        ['key1', createCacheEntry({ name: 'test1' }, 3600)],
+        ['key2', createCacheEntry({ name: 'test2' }, 3600)]
+      ]);
+
+      await cache.setMany(entries);
+
+      const result1 = await cache.get<{ name: string }>('key1');
+      const result2 = await cache.get<{ name: string }>('key2');
+
+      expect(result1?.data.name).toBe('test1');
+      expect(result2?.data.name).toBe('test2');
+    });
+
+    it('should handle empty entries map', async () => {
+      await cache.setMany(new Map());
+
+      // Should not throw
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return cache statistics', async () => {
+      const entry = createCacheEntry({ name: 'test' }, 3600);
+      await cache.set('key1', entry);
+
+      await cache.get('key1'); // Hit
+      await cache.get('key2'); // Miss
+
+      const stats = await cache.getStats();
+
+      expect(stats.hits).toBe(1);
+      expect(stats.misses).toBe(1);
+      expect(stats.hitRatio).toBe(0.5);
+    });
+
+    it('should return size from dbsize', async () => {
+      const stats = await cache.getStats();
+
+      expect(mockClient.dbsize).toHaveBeenCalled();
+    });
+
+    it('should return bytes from info', async () => {
+      const stats = await cache.getStats();
+
+      expect(stats.bytes).toBe(1024);
+    });
+  });
+
+  describe('close', () => {
+    it('should close Redis connection', async () => {
+      await cache.close();
+
+      expect(mockClient.quit).toHaveBeenCalled();
+    });
+  });
+});
+
+describe('createRedisCache', () => {
+  it('should create a RedisCache instance', () => {
+    const mockClient = createMockRedisClient();
+    const cache = createRedisCache({ client: mockClient });
+
+    expect(cache).toBeInstanceOf(RedisCache);
+  });
+
+  it('should accept configuration options', () => {
+    const mockClient = createMockRedisClient();
+    const cache = createRedisCache({
+      client: mockClient,
+      keyPrefix: 'custom-prefix',
+      defaultTTL: 7200
+    });
+
+    expect(cache).toBeInstanceOf(RedisCache);
+  });
+});

package/packages/core/src/__tests__/rust-extractor.test.ts

@@ -0,0 +1,252 @@
+/**
+ * @fileoverview Unit tests for Rust extractor
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { RustExtractor } from '../extractors/rust-extractor';
+
+describe('RustExtractor', () => {
+  let extractor: RustExtractor;
+
+  beforeEach(() => {
+    extractor = new RustExtractor();
+  });
+
+  describe('extract', () => {
+    describe('Actix-web routes', () => {
+      it('should extract GET routes', async () => {
+        const code = `
+use actix_web::{get, web, HttpResponse};
+
+#[get("/users/{id}")]
+async fn get_user(path: web::Path<String>) -> HttpResponse {
+    HttpResponse::Ok().finish()
+}
+        `;
+
+        const tools = await extractor.extract(code, 'handlers.rs');
+
+        expect(tools.length).toBeGreaterThan(0);
+        const tool = tools.find(t => t.name.includes('get_users'));
+        expect(tool).toBeDefined();
+        expect(tool?.inputSchema.properties).toHaveProperty('id');
+      });
+
+      it('should extract POST routes', async () => {
+        const code = `
+use actix_web::{post, web, HttpResponse};
+
+#[post("/users")]
+async fn create_user(body: web::Json<CreateUser>) -> HttpResponse {
+    HttpResponse::Created().finish()
+}
+        `;
+
+        const tools = await extractor.extract(code, 'handlers.rs');
+
+        expect(tools.length).toBeGreaterThan(0);
+        const tool = tools.find(t => t.name.includes('post_users'));
+        expect(tool).toBeDefined();
+      });
+
+      it('should extract web::resource routes', async () => {
+        const code = `
+use actix_web::{web, App};
+
+fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(
+        web::resource("/items")
+            .route(web::get().to(list_items))
+            .route(web::post().to(create_item))
+    );
+}
+        `;
+
+        const tools = await extractor.extract(code, 'config.rs');
+
+        expect(tools.length).toBeGreaterThan(0);
+      });
+    });
+
+    describe('Axum routes', () => {
+      it('should extract router routes', async () => {
+        const code = `
+use axum::{Router, routing::get};
+
+fn create_router() -> Router {
+    Router::new()
+        .route("/api/users", get(list_users))
+        .route("/api/users/:id", get(get_user))
+}
+        `;
+
+        const tools = await extractor.extract(code, 'router.rs');
+
+        expect(tools.length).toBeGreaterThan(0);
+        expect(tools.some(t => t.name.includes('api_users'))).toBe(true);
+      });
+
+      it('should extract debug_handler functions', async () => {
+        const code = `
+use axum::debug_handler;
+
+#[debug_handler]
+async fn my_handler() -> impl IntoResponse {
+    "Hello"
+}
+        `;
+
+        const tools = await extractor.extract(code, 'handlers.rs');
+
+        expect(tools.some(t => t.name === 'my_handler')).toBe(true);
+      });
+    });
+
+    describe('Rocket routes', () => {
+      it('should extract Rocket routes with data', async () => {
+        const code = `
+use rocket::serde::json::Json;
+
+#[post("/users", data = "<user>")]
+async fn create_user(user: Json<CreateUser>) -> Json<User> {
+    // Create user
+}
+        `;
+
+        const tools = await extractor.extract(code, 'routes.rs');
+
+        expect(tools.length).toBeGreaterThan(0);
+        const tool = tools.find(t => t.name.includes('post_users'));
+        expect(tool).toBeDefined();
+      });
+    });
+
+    describe('Public functions', () => {
+      it('should extract public functions with doc comments', async () => {
+        const code = `
+/// Calculate the sum of two numbers
+///
+/// # Arguments
+/// * \`a\` - First number
+/// * \`b\` - Second number
+pub fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
+        `;
+
+        const tools = await extractor.extract(code, 'math.rs');
+
+        expect(tools.length).toBeGreaterThan(0);
+        const tool = tools.find(t => t.name === 'add');
+        expect(tool).toBeDefined();
+        expect(tool?.description).toContain('sum');
+      });
+
+      it('should extract async public functions', async () => {
+        const code = `
+/// Fetch data from the API
+pub async fn fetch_data(url: String) -> Result<Data, Error> {
+    // Fetch data
+}
+        `;
+
+        const tools = await extractor.extract(code, 'client.rs');
+
+        expect(tools.some(t => t.name === 'fetch_data')).toBe(true);
+      });
+
+      it('should skip functions without documentation', async () => {
+        const code = `
+pub fn undocumented_function(x: i32) -> i32 {
+    x
+}
+
+/// Documented function
+pub fn documented_function(x: i32) -> i32 {
+    x
+}
+        `;
+
+        const tools = await extractor.extract(code, 'lib.rs');
+
+        // Only documented function should be included in public function extraction
+        // (but it might also be skipped if not considered useful)
+        expect(tools.every(t => t.name !== 'undocumented_function' || t.documentation !== null)).toBe(true);
+      });
+    });
+
+    describe('Type conversion', () => {
+      it('should convert Rust types to JSON schema types', async () => {
+        const code = `
+/// Process data
+pub fn process(
+    name: String,
+    count: i32,
+    enabled: bool,
+    items: Vec<String>,
+    config: HashMap<String, Value>
+) -> Result<(), Error> {
+    // Process
+}
+        `;
+
+        const tools = await extractor.extract(code, 'processor.rs');
+
+        const tool = tools.find(t => t.name === 'process');
+        expect(tool?.inputSchema.properties.name?.type).toBe('string');
+        expect(tool?.inputSchema.properties.count?.type).toBe('integer');
+        expect(tool?.inputSchema.properties.enabled?.type).toBe('boolean');
+        expect(tool?.inputSchema.properties.items?.type).toBe('array');
+        expect(tool?.inputSchema.properties.config?.type).toBe('object');
+      });
+
+      it('should handle Option types', async () => {
+        const code = `
+/// Get user with optional email
+pub fn get_user(id: String, email: Option<String>) -> User {
+    // Get user
+}
+        `;
+
+        const tools = await extractor.extract(code, 'users.rs');
+
+        const tool = tools.find(t => t.name === 'get_user');
+        // Required should only include 'id', not 'email'
+        expect(tool?.inputSchema.required).toContain('id');
+      });
+    });
+
+    describe('Path parameter extraction', () => {
+      it('should extract path parameters from Actix routes', async () => {
+        const code = `
+#[get("/users/{user_id}/posts/{post_id}")]
+async fn get_post(path: web::Path<(String, String)>) -> HttpResponse {
+    HttpResponse::Ok().finish()
+}
+        `;
+
+        const tools = await extractor.extract(code, 'handlers.rs');
+
+        const tool = tools[0];
+        expect(tool?.inputSchema.properties).toHaveProperty('user_id');
+        expect(tool?.inputSchema.properties).toHaveProperty('post_id');
+        expect(tool?.inputSchema.required).toContain('user_id');
+        expect(tool?.inputSchema.required).toContain('post_id');
+      });
+
+      it('should extract path parameters from Rocket routes', async () => {
+        const code = `
+#[get("/items/<item_id>")]
+fn get_item(item_id: i32) -> String {
+    format!("Item {}", item_id)
+}
+        `;
+
+        const tools = await extractor.extract(code, 'routes.rs');
+
+        const tool = tools[0];
+        expect(tool?.inputSchema.properties).toHaveProperty('item_id');
+      });
+    });
+  });
+});