@nahisaho/shikigami-mcp-server 1.7.0 → 1.10.0

package/src/tools/visit/recovery/__tests__/index.test.ts

@@ -0,0 +1,297 @@
+/**
+ * VisitRecoveryManager テスト
+ *
+ * TSK-1-004: VisitRecoveryManager実装
+ * REQ-SRCH-004-01: visit失敗時フォールバック
+ * REQ-SRCH-004-02: 自動リトライ
+ * REQ-SRCH-004-03: 結果マージ
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import {
+  VisitRecoveryManager,
+  createVisitRecoveryManager,
+  DEFAULT_VISIT_RECOVERY_CONFIG,
+  type PageFetchResult,
+} from '../index.js';
+import { RecoveryLogger } from '../../../search/recovery/logger.js';
+
+// globalThis.fetch をモック（WaybackClient用）
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+
+describe('VisitRecoveryManager', () => {
+  let manager: VisitRecoveryManager;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    mockFetch.mockReset();
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    manager = new VisitRecoveryManager({
+      retryDelayMs: 10, // テスト高速化
+    });
+  });
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore();
+  });
+
+  describe('constructor', () => {
+    it('should use default config when no config provided', () => {
+      const manager = new VisitRecoveryManager();
+      expect(manager).toBeInstanceOf(VisitRecoveryManager);
+    });
+
+    it('should merge custom config with defaults', () => {
+      const manager = new VisitRecoveryManager({ maxRetries: 5 });
+      expect(manager).toBeInstanceOf(VisitRecoveryManager);
+    });
+
+    it('should disable wayback when enableWayback is false', () => {
+      const manager = new VisitRecoveryManager({ enableWayback: false });
+      expect(manager.getWaybackClient()).toBeNull();
+    });
+
+    it('should use provided logger instance', () => {
+      const customLogger = new RecoveryLogger({ warnThreshold: 100 });
+      const manager = new VisitRecoveryManager({ logger: customLogger });
+      expect(manager.getLogger()).toBe(customLogger);
+    });
+  });
+
+  describe('recover', () => {
+    it('should return success on first attempt when fetch succeeds', async () => {
+      const mockFetchFn = vi.fn().mockResolvedValue({
+        success: true,
+        content: 'Test content',
+        title: 'Test Title',
+      });
+
+      const result = await manager.recover('https://example.com', mockFetchFn);
+
+      expect(result.success).toBe(true);
+      expect(result.content).toBe('Test content');
+      expect(result.title).toBe('Test Title');
+      expect(result.usedWayback).toBe(false);
+      expect(result.attempts).toBe(1);
+      expect(mockFetchFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('should retry on failure', async () => {
+      const mockFetchFn = vi
+        .fn()
+        .mockResolvedValueOnce({ success: false, error: 'Network error' })
+        .mockResolvedValueOnce({ success: false, error: 'Network error' })
+        .mockResolvedValueOnce({
+          success: true,
+          content: 'Test content',
+          title: 'Test Title',
+        });
+
+      const result = await manager.recover('https://example.com', mockFetchFn);
+
+      expect(result.success).toBe(true);
+      expect(result.attempts).toBe(3);
+      expect(mockFetchFn).toHaveBeenCalledTimes(3);
+    });
+
+    it('should try wayback after all direct retries fail', async () => {
+      const mockFetchFn = vi
+        .fn()
+        .mockResolvedValue({ success: false, error: 'Page not found' });
+
+      // Wayback API mock
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          url: 'https://example.com',
+          archived_snapshots: {
+            closest: {
+              url: 'https://web.archive.org/web/20240101/https://example.com',
+              timestamp: '20240101120000',
+              available: true,
+            },
+          },
+        }),
+      });
+
+      // Wayback取得も失敗
+      const result = await manager.recover('https://example.com', mockFetchFn);
+
+      expect(result.success).toBe(false);
+      expect(mockFetch).toHaveBeenCalled(); // Wayback APIが呼ばれた
+    });
+
+    it('should return wayback content on wayback success', async () => {
+      const mockFetchFn = vi
+        .fn()
+        .mockImplementation((url: string) => {
+          if (url.includes('web.archive.org')) {
+            return Promise.resolve({
+              success: true,
+              content: 'Archived content',
+              title: 'Archived Title',
+            });
+          }
+          return Promise.resolve({ success: false, error: 'Page not found' });
+        });
+
+      // Wayback API mock
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          url: 'https://example.com',
+          archived_snapshots: {
+            closest: {
+              url: 'https://web.archive.org/web/20240101/https://example.com',
+              timestamp: '20240101120000',
+              available: true,
+            },
+          },
+        }),
+      });
+
+      const result = await manager.recover('https://example.com', mockFetchFn);
+
+      expect(result.success).toBe(true);
+      expect(result.usedWayback).toBe(true);
+      expect(result.content).toBe('Archived content');
+      expect(result.waybackSnapshot).toBeDefined();
+    });
+
+    it('should return failure when all attempts fail', async () => {
+      const mockFetchFn = vi.fn().mockResolvedValue({
+        success: false,
+        error: 'Page not found',
+      });
+
+      // Wayback API mock - no archive available
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          url: 'https://example.com',
+          archived_snapshots: {},
+        }),
+      });
+
+      const result = await manager.recover('https://example.com', mockFetchFn);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+      expect(result.attempts).toBeGreaterThan(0);
+    });
+
+    it('should handle fetch function throwing errors', async () => {
+      const mockFetchFn = vi.fn().mockRejectedValue(new Error('Network error'));
+
+      // Wayback API mock - no archive
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          url: 'https://example.com',
+          archived_snapshots: {},
+        }),
+      });
+
+      const result = await manager.recover('https://example.com', mockFetchFn);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it('should skip wayback when enableWayback is false', async () => {
+      const noWaybackManager = new VisitRecoveryManager({
+        enableWayback: false,
+        maxRetries: 1,
+        retryDelayMs: 10,
+      });
+
+      const mockFetchFn = vi.fn().mockResolvedValue({
+        success: false,
+        error: 'Page not found',
+      });
+
+      const result = await noWaybackManager.recover('https://example.com', mockFetchFn);
+
+      expect(result.success).toBe(false);
+      expect(result.usedWayback).toBe(false);
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('logging', () => {
+    it('should log attempts to RecoveryLogger', async () => {
+      const mockFetchFn = vi.fn().mockResolvedValue({
+        success: true,
+        content: 'Test content',
+        title: 'Test Title',
+      });
+
+      await manager.recover('https://example.com', mockFetchFn);
+
+      const entries = manager.getLogger().getEntries();
+      expect(entries.length).toBeGreaterThan(0);
+      expect(entries[0].type).toBe('visit');
+    });
+
+    it('should output to stderr', async () => {
+      const mockFetchFn = vi.fn().mockResolvedValue({
+        success: true,
+        content: 'Test content',
+        title: 'Test Title',
+      });
+
+      await manager.recover('https://example.com', mockFetchFn);
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[VisitRecovery]')
+      );
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return stats from logger', async () => {
+      const mockFetchFn = vi.fn().mockResolvedValue({
+        success: true,
+        content: 'Test content',
+        title: 'Test Title',
+      });
+
+      await manager.recover('https://example.com', mockFetchFn);
+
+      const stats = manager.getStats();
+      expect(stats.totalAttempts).toBeGreaterThan(0);
+    });
+  });
+
+  describe('createVisitRecoveryManager', () => {
+    it('should create a VisitRecoveryManager instance', () => {
+      const manager = createVisitRecoveryManager();
+      expect(manager).toBeInstanceOf(VisitRecoveryManager);
+    });
+
+    it('should create with custom config', () => {
+      const manager = createVisitRecoveryManager({ maxRetries: 5 });
+      expect(manager).toBeInstanceOf(VisitRecoveryManager);
+    });
+  });
+
+  describe('timeout handling', () => {
+    it('should timeout long-running fetch', async () => {
+      const slowManager = new VisitRecoveryManager({
+        timeoutMs: 100,
+        maxRetries: 0,
+        enableWayback: false,
+      });
+
+      const mockFetchFn = vi.fn().mockImplementation(
+        () => new Promise((resolve) => setTimeout(() => resolve({ success: true }), 500))
+      );
+
+      const result = await slowManager.recover('https://example.com', mockFetchFn);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('timed out');
+    });
+  });
+});

package/src/tools/visit/recovery/__tests__/wayback.test.ts

@@ -0,0 +1,344 @@
+/**
+ * WaybackClient テスト
+ *
+ * TSK-1-003: WaybackClient実装
+ * REQ-SRCH-004-01: visit失敗時フォールバック
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import {
+  WaybackClient,
+  createWaybackClient,
+  DEFAULT_WAYBACK_CONFIG,
+  type WaybackApiResponse,
+  type WaybackSnapshot,
+} from '../wayback.js';
+
+// globalThis.fetch をモック
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+
+describe('WaybackClient', () => {
+  let client: WaybackClient;
+
+  beforeEach(() => {
+    client = new WaybackClient();
+    mockFetch.mockReset();
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should use default config when no config provided', () => {
+      const client = new WaybackClient();
+      expect(client).toBeInstanceOf(WaybackClient);
+    });
+
+    it('should merge custom config with defaults', () => {
+      const client = new WaybackClient({ timeoutMs: 5000 });
+      expect(client).toBeInstanceOf(WaybackClient);
+    });
+  });
+
+  describe('getSnapshot', () => {
+    it('should return snapshot when archive is available', async () => {
+      const mockResponse: WaybackApiResponse = {
+        url: 'https://example.com',
+        archived_snapshots: {
+          closest: {
+            url: 'https://web.archive.org/web/20240101120000/https://example.com',
+            timestamp: '20240101120000',
+            available: true,
+            status: '200',
+          },
+        },
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      });
+
+      const result = await client.getSnapshot('https://example.com');
+
+      expect(result).not.toBeNull();
+      expect(result?.url).toBe('https://web.archive.org/web/20240101120000/https://example.com');
+      expect(result?.originalUrl).toBe('https://example.com');
+      expect(result?.available).toBe(true);
+      expect(result?.timestamp).toBe('2024-01-01T12:00:00Z');
+      expect(result?.status).toBe(200);
+    });
+
+    it('should return null when no archive is available', async () => {
+      const mockResponse: WaybackApiResponse = {
+        url: 'https://example.com',
+        archived_snapshots: {},
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      });
+
+      const result = await client.getSnapshot('https://example.com');
+
+      expect(result).toBeNull();
+    });
+
+    it('should retry on failure', async () => {
+      const mockResponse: WaybackApiResponse = {
+        url: 'https://example.com',
+        archived_snapshots: {
+          closest: {
+            url: 'https://web.archive.org/web/20240101120000/https://example.com',
+            timestamp: '20240101120000',
+            available: true,
+          },
+        },
+      };
+
+      // 最初の2回は失敗、3回目で成功
+      mockFetch
+        .mockRejectedValueOnce(new Error('Network error'))
+        .mockRejectedValueOnce(new Error('Network error'))
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => mockResponse,
+        });
+
+      // リトライ間隔を短くして高速化
+      const fastClient = new WaybackClient({ retryDelayMs: 10 });
+      const result = await fastClient.getSnapshot('https://example.com');
+
+      expect(result).not.toBeNull();
+      expect(mockFetch).toHaveBeenCalledTimes(3);
+    });
+
+    it('should return null after all retries fail', async () => {
+      mockFetch.mockRejectedValue(new Error('Network error'));
+
+      const fastClient = new WaybackClient({ retryDelayMs: 10, maxRetries: 2 });
+      const result = await fastClient.getSnapshot('https://example.com');
+
+      expect(result).toBeNull();
+      expect(mockFetch).toHaveBeenCalledTimes(3); // 初回 + 2回リトライ
+    });
+
+    it('should handle HTTP errors', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 503,
+        statusText: 'Service Unavailable',
+      });
+
+      const fastClient = new WaybackClient({ retryDelayMs: 10, maxRetries: 0 });
+      const result = await fastClient.getSnapshot('https://example.com');
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle timeout', async () => {
+      // タイムアウトをシミュレート
+      mockFetch.mockImplementation(
+        () =>
+          new Promise((_, reject) => {
+            const error = new Error('Aborted');
+            error.name = 'AbortError';
+            reject(error);
+          })
+      );
+
+      const fastClient = new WaybackClient({ timeoutMs: 100, maxRetries: 0 });
+      const result = await fastClient.getSnapshot('https://example.com');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('isArchived', () => {
+    it('should return true when archive is available', async () => {
+      const mockResponse: WaybackApiResponse = {
+        url: 'https://example.com',
+        archived_snapshots: {
+          closest: {
+            url: 'https://web.archive.org/web/20240101120000/https://example.com',
+            timestamp: '20240101120000',
+            available: true,
+          },
+        },
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      });
+
+      const result = await client.isArchived('https://example.com');
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false when no archive is available', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          url: 'https://example.com',
+          archived_snapshots: {},
+        }),
+      });
+
+      const result = await client.isArchived('https://example.com');
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false on error', async () => {
+      mockFetch.mockRejectedValue(new Error('Network error'));
+
+      const fastClient = new WaybackClient({ retryDelayMs: 10, maxRetries: 0 });
+      const result = await fastClient.isArchived('https://example.com');
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getArchiveUrl', () => {
+    it('should return archive URL when available', async () => {
+      const mockResponse: WaybackApiResponse = {
+        url: 'https://example.com',
+        archived_snapshots: {
+          closest: {
+            url: 'https://web.archive.org/web/20240101120000/https://example.com',
+            timestamp: '20240101120000',
+            available: true,
+          },
+        },
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      });
+
+      const result = await client.getArchiveUrl('https://example.com');
+
+      expect(result).toBe('https://web.archive.org/web/20240101120000/https://example.com');
+    });
+
+    it('should return null when not available', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          url: 'https://example.com',
+          archived_snapshots: {},
+        }),
+      });
+
+      const result = await client.getArchiveUrl('https://example.com');
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null when available is false', async () => {
+      const mockResponse: WaybackApiResponse = {
+        url: 'https://example.com',
+        archived_snapshots: {
+          closest: {
+            url: 'https://web.archive.org/web/20240101120000/https://example.com',
+            timestamp: '20240101120000',
+            available: false,
+          },
+        },
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      });
+
+      const result = await client.getArchiveUrl('https://example.com');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('createWaybackClient', () => {
+    it('should create a WaybackClient instance', () => {
+      const client = createWaybackClient();
+      expect(client).toBeInstanceOf(WaybackClient);
+    });
+
+    it('should create a WaybackClient with custom config', () => {
+      const client = createWaybackClient({ timeoutMs: 5000 });
+      expect(client).toBeInstanceOf(WaybackClient);
+    });
+  });
+
+  describe('timestamp formatting', () => {
+    it('should format valid timestamp to ISO 8601', async () => {
+      const mockResponse: WaybackApiResponse = {
+        url: 'https://example.com',
+        archived_snapshots: {
+          closest: {
+            url: 'https://web.archive.org/web/20231215143025/https://example.com',
+            timestamp: '20231215143025',
+            available: true,
+          },
+        },
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      });
+
+      const result = await client.getSnapshot('https://example.com');
+
+      expect(result?.timestamp).toBe('2023-12-15T14:30:25Z');
+    });
+
+    it('should return invalid timestamp as-is', async () => {
+      const mockResponse: WaybackApiResponse = {
+        url: 'https://example.com',
+        archived_snapshots: {
+          closest: {
+            url: 'https://web.archive.org/web/invalid/https://example.com',
+            timestamp: 'invalid',
+            available: true,
+          },
+        },
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => mockResponse,
+      });
+
+      const result = await client.getSnapshot('https://example.com');
+
+      expect(result?.timestamp).toBe('invalid');
+    });
+  });
+
+  describe('API URL encoding', () => {
+    it('should properly encode URL with special characters', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          url: 'https://example.com/path?query=value&foo=bar',
+          archived_snapshots: {},
+        }),
+      });
+
+      await client.getSnapshot('https://example.com/path?query=value&foo=bar');
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.stringContaining(encodeURIComponent('https://example.com/path?query=value&foo=bar')),
+        expect.any(Object)
+      );
+    });
+  });
+});