@dependabit/monitor 0.1.1

package/test/comparator.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { StateComparator } from '../src/comparator.js';
+
+describe('StateComparator', () => {
+  let comparator: StateComparator;
+
+  beforeEach(() => {
+    comparator = new StateComparator();
+  });
+
+  describe('compare', () => {
+    it('should detect state hash changes', () => {
+      const oldState = {
+        stateHash: 'abc123',
+        version: 'v1.0.0',
+        fetchedAt: new Date('2024-01-01')
+      };
+
+      const newState = {
+        stateHash: 'def456',
+        version: 'v1.0.0',
+        fetchedAt: new Date('2024-01-02')
+      };
+
+      const result = comparator.compare(oldState, newState);
+
+      expect(result.hasChanged).toBe(true);
+      expect(result.changes).toContain('stateHash');
+    });
+
+    it('should detect version changes', () => {
+      const oldState = {
+        stateHash: 'abc123',
+        version: 'v1.0.0',
+        fetchedAt: new Date('2024-01-01')
+      };
+
+      const newState = {
+        stateHash: 'abc123',
+        version: 'v2.0.0',
+        fetchedAt: new Date('2024-01-02')
+      };
+
+      const result = comparator.compare(oldState, newState);
+
+      expect(result.hasChanged).toBe(true);
+      expect(result.changes).toContain('version');
+    });
+
+    it('should return no change when states match', () => {
+      const oldState = {
+        stateHash: 'abc123',
+        version: 'v1.0.0',
+        fetchedAt: new Date('2024-01-01')
+      };
+
+      const newState = {
+        stateHash: 'abc123',
+        version: 'v1.0.0',
+        fetchedAt: new Date('2024-01-02')
+      };
+
+      const result = comparator.compare(oldState, newState);
+
+      expect(result.hasChanged).toBe(false);
+      expect(result.changes).toHaveLength(0);
+    });
+
+    it('should detect multiple changes', () => {
+      const oldState = {
+        stateHash: 'abc123',
+        version: 'v1.0.0',
+        metadata: { author: 'Alice' },
+        fetchedAt: new Date('2024-01-01')
+      };
+
+      const newState = {
+        stateHash: 'def456',
+        version: 'v2.0.0',
+        metadata: { author: 'Bob' },
+        fetchedAt: new Date('2024-01-02')
+      };
+
+      const result = comparator.compare(oldState, newState);
+
+      expect(result.hasChanged).toBe(true);
+      expect(result.changes.length).toBeGreaterThan(1);
+    });
+
+    it('should handle missing version in old state', () => {
+      const oldState = {
+        stateHash: 'abc123',
+        fetchedAt: new Date('2024-01-01')
+      };
+
+      const newState = {
+        stateHash: 'abc123',
+        version: 'v1.0.0',
+        fetchedAt: new Date('2024-01-02')
+      };
+
+      const result = comparator.compare(oldState, newState);
+
+      expect(result.hasChanged).toBe(true);
+      expect(result.changes).toContain('version');
+    });
+  });
+});

package/test/monitor.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Monitor } from '../src/monitor.js';
+
+// Mock global fetch to prevent real network calls
+const mockFetch = vi.fn();
+global.fetch = mockFetch as any;
+
+describe('Monitor', () => {
+  let monitor: Monitor;
+
+  beforeEach(() => {
+    monitor = new Monitor();
+    vi.clearAllMocks();
+
+    // Mock successful fetch responses by default
+    mockFetch.mockImplementation((url: string) => {
+      // Fail for invalid URLs
+      if (url.includes('invalid-url')) {
+        return Promise.reject(new Error('Network error'));
+      }
+
+      // Success response
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: async () => ({
+          tag_name: 'v1.0.0',
+          name: 'Release v1.0.0',
+          published_at: '2024-01-01T00:00:00Z',
+          body: 'Release notes',
+          html_url: 'https://github.com/owner/repo/releases/v1.0.0'
+        }),
+        headers: {
+          get: (name: string) => (name === 'content-type' ? 'text/html' : null)
+        },
+        text: async () => '<html><body>Test content</body></html>'
+      });
+    });
+  });
+
+  describe('checkDependency', () => {
+    it('should check a single dependency and detect changes', async () => {
+      const dependency = {
+        id: 'test-id',
+        url: 'https://github.com/owner/repo',
+        type: 'reference-implementation' as const,
+        accessMethod: 'github-api' as const,
+        currentStateHash: 'old-hash'
+      };
+
+      const result = await monitor.checkDependency(dependency);
+
+      expect(result).toBeDefined();
+      expect(result.dependency).toEqual(dependency);
+      expect(result.hasChanged).toBeDefined();
+    });
+
+    it('should handle errors gracefully', async () => {
+      mockFetch.mockRejectedValue(new Error('Network error'));
+
+      const dependency = {
+        id: 'test-id',
+        url: 'https://invalid-url.com',
+        type: 'documentation' as const,
+        accessMethod: 'http' as const,
+        currentStateHash: 'old-hash'
+      };
+
+      const result = await monitor.checkDependency(dependency);
+
+      expect(result).toBeDefined();
+      expect(result.error).toBeDefined();
+    });
+
+    it('should use appropriate checker based on access method', async () => {
+      const githubDep = {
+        id: 'github-id',
+        url: 'https://github.com/owner/repo',
+        type: 'reference-implementation' as const,
+        accessMethod: 'github-api' as const,
+        currentStateHash: 'hash1'
+      };
+
+      const httpDep = {
+        id: 'http-id',
+        url: 'https://example.com/docs',
+        type: 'documentation' as const,
+        accessMethod: 'http' as const,
+        currentStateHash: 'hash2'
+      };
+
+      const result1 = await monitor.checkDependency(githubDep);
+      const result2 = await monitor.checkDependency(httpDep);
+
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+    });
+  });
+
+  describe('checkAll', () => {
+    it('should check multiple dependencies in parallel', async () => {
+      const dependencies = [
+        {
+          id: 'dep1',
+          url: 'https://github.com/owner/repo1',
+          type: 'reference-implementation' as const,
+          accessMethod: 'github-api' as const,
+          currentStateHash: 'hash1'
+        },
+        {
+          id: 'dep2',
+          url: 'https://github.com/owner/repo2',
+          type: 'reference-implementation' as const,
+          accessMethod: 'github-api' as const,
+          currentStateHash: 'hash2'
+        }
+      ];
+
+      const results = await monitor.checkAll(dependencies);
+
+      expect(results).toHaveLength(2);
+      expect(results[0].dependency.id).toBe('dep1');
+      expect(results[1].dependency.id).toBe('dep2');
+    });
+
+    it('should handle mixed success and errors', async () => {
+      const dependencies = [
+        {
+          id: 'valid',
+          url: 'https://github.com/owner/repo',
+          type: 'reference-implementation' as const,
+          accessMethod: 'github-api' as const,
+          currentStateHash: 'hash1'
+        },
+        {
+          id: 'invalid',
+          url: 'https://invalid-url.com',
+          type: 'documentation' as const,
+          accessMethod: 'http' as const,
+          currentStateHash: 'hash2'
+        }
+      ];
+
+      const results = await monitor.checkAll(dependencies);
+
+      expect(results).toHaveLength(2);
+      expect(results.some((r) => !r.error)).toBe(true);
+      expect(results.some((r) => r.error)).toBe(true);
+    });
+
+    it('should respect monitoring rules', async () => {
+      const dependencies = [
+        {
+          id: 'enabled',
+          url: 'https://github.com/owner/repo',
+          type: 'reference-implementation' as const,
+          accessMethod: 'github-api' as const,
+          currentStateHash: 'hash1',
+          monitoring: { enabled: true }
+        },
+        {
+          id: 'disabled',
+          url: 'https://github.com/owner/repo2',
+          type: 'reference-implementation' as const,
+          accessMethod: 'github-api' as const,
+          currentStateHash: 'hash2',
+          monitoring: { enabled: false }
+        }
+      ];
+
+      const results = await monitor.checkAll(dependencies);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].dependency.id).toBe('enabled');
+    });
+  });
+});

package/test/normalizer.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeHTML } from '../src/normalizer.js';
+
+describe('HTML Normalizer', () => {
+  describe('normalizeHTML', () => {
+    it('should remove script tags', () => {
+      const html = '<div>Content<script>alert("test")</script></div>';
+      const result = normalizeHTML(html);
+      expect(result).not.toContain('<script>');
+      expect(result).not.toContain('alert');
+    });
+
+    it('should remove style tags', () => {
+      const html = '<div>Content<style>.class { color: red; }</style></div>';
+      const result = normalizeHTML(html);
+      expect(result).not.toContain('<style>');
+      expect(result).not.toContain('color: red');
+    });
+
+    it('should strip HTML comments', () => {
+      const html = '<div>Content<!-- This is a comment --></div>';
+      const result = normalizeHTML(html);
+      expect(result).not.toContain('<!--');
+      expect(result).not.toContain('-->');
+    });
+
+    it('should normalize whitespace', () => {
+      const html = '<div>Content     with    multiple   spaces</div>';
+      const result = normalizeHTML(html);
+      expect(result).toContain('Content with multiple spaces');
+    });
+
+    it('should remove timestamp patterns', () => {
+      const html = '<div>Updated: 2024-01-01 12:00:00</div><div>Last modified: Jan 1, 2024</div>';
+      const result = normalizeHTML(html);
+      expect(result).not.toContain('Updated:');
+      expect(result).not.toContain('Last modified:');
+    });
+
+    it('should remove analytics tracking parameters', () => {
+      const html = '<a href="https://example.com?utm_source=test&utm_campaign=ad">Link</a>';
+      const result = normalizeHTML(html);
+      expect(result).not.toContain('utm_source');
+      expect(result).not.toContain('utm_campaign');
+    });
+
+    it('should preserve meaningful content', () => {
+      const html = '<h1>API Documentation</h1><p>This is the main content.</p>';
+      const result = normalizeHTML(html);
+      expect(result).toContain('API Documentation');
+      expect(result).toContain('This is the main content');
+    });
+
+    it('should handle empty input', () => {
+      const result = normalizeHTML('');
+      expect(result).toBe('');
+    });
+
+    it('should produce consistent output', () => {
+      const html = '<div>Test<script>x()</script>  </div>';
+      const result1 = normalizeHTML(html);
+      const result2 = normalizeHTML(html);
+      expect(result1).toBe(result2);
+    });
+  });
+});