digital-tools 2.0.2 → 2.1.1

package/test/tools.test.js

@@ -0,0 +1,363 @@
+/**
+ * Tests for Pre-built Tools
+ *
+ * Covers web, data, and communication tools.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { 
+// Web tools
+fetchUrl, parseHtml, readUrl, webTools, 
+// Data tools
+parseJson, stringifyJson, parseCsv, transformData, filterData, dataTools, 
+// Communication tools
+sendEmail, sendSlackMessage, sendNotification, sendSms, communicationTools, 
+// Utilities
+getBuiltinTools, registerBuiltinTools, registry, } from '../src/index.js';
+describe('Web Tools', () => {
+    describe('fetchUrl', () => {
+        it('has correct metadata', () => {
+            expect(fetchUrl.id).toBe('web.fetch');
+            expect(fetchUrl.name).toBe('Fetch URL');
+            expect(fetchUrl.category).toBe('web');
+            expect(fetchUrl.subcategory).toBe('fetch');
+        });
+        it('has required parameters', () => {
+            const urlParam = fetchUrl.parameters.find(p => p.name === 'url');
+            expect(urlParam).toBeDefined();
+            expect(urlParam?.required).toBe(true);
+        });
+        it('has optional parameters', () => {
+            const methodParam = fetchUrl.parameters.find(p => p.name === 'method');
+            expect(methodParam).toBeDefined();
+            expect(methodParam?.required).toBe(false);
+        });
+        it('has audience and tags', () => {
+            expect(fetchUrl.audience).toBe('both');
+            expect(fetchUrl.tags).toContain('http');
+        });
+    });
+    describe('parseHtml', () => {
+        it('has correct metadata', () => {
+            expect(parseHtml.id).toBe('web.parse-html');
+            expect(parseHtml.category).toBe('web');
+            expect(parseHtml.subcategory).toBe('scrape');
+        });
+        it('extracts text from HTML', async () => {
+            const result = await parseHtml.handler({
+                html: '<p>Hello World</p>',
+            });
+            expect(result.text).toContain('Hello World');
+        });
+        it('extracts links from HTML', async () => {
+            const result = await parseHtml.handler({
+                html: '<a href="https://example.com">Link</a>',
+            });
+            expect(result.links).toContain('https://example.com');
+        });
+        it('extracts images from HTML', async () => {
+            const result = await parseHtml.handler({
+                html: '<img src="image.jpg" />',
+            });
+            expect(result.images).toContain('image.jpg');
+        });
+    });
+    describe('readUrl', () => {
+        it('has correct metadata', () => {
+            expect(readUrl.id).toBe('web.read');
+            expect(readUrl.category).toBe('web');
+            expect(readUrl.idempotent).toBe(true);
+        });
+    });
+    describe('webTools array', () => {
+        it('contains all web tools', () => {
+            expect(webTools).toHaveLength(3);
+            expect(webTools.map(t => t.id)).toContain('web.fetch');
+            expect(webTools.map(t => t.id)).toContain('web.parse-html');
+            expect(webTools.map(t => t.id)).toContain('web.read');
+        });
+    });
+});
+describe('Data Tools', () => {
+    describe('parseJson', () => {
+        it('has correct metadata', () => {
+            expect(parseJson.id).toBe('data.json.parse');
+            expect(parseJson.category).toBe('data');
+            expect(parseJson.subcategory).toBe('transform');
+        });
+        it('parses valid JSON', async () => {
+            const result = await parseJson.handler({
+                text: '{"name": "John", "age": 30}',
+            });
+            expect(result.valid).toBe(true);
+            expect(result.data).toEqual({ name: 'John', age: 30 });
+        });
+        it('handles invalid JSON', async () => {
+            const result = await parseJson.handler({
+                text: '{invalid}',
+            });
+            expect(result.valid).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+        it('is idempotent', () => {
+            expect(parseJson.idempotent).toBe(true);
+        });
+    });
+    describe('stringifyJson', () => {
+        it('has correct metadata', () => {
+            expect(stringifyJson.id).toBe('data.json.stringify');
+            expect(stringifyJson.category).toBe('data');
+        });
+        it('stringifies object', async () => {
+            const result = await stringifyJson.handler({
+                data: { name: 'John' },
+            });
+            expect(result.text).toBe('{"name":"John"}');
+        });
+        it('supports pretty printing', async () => {
+            const result = await stringifyJson.handler({
+                data: { name: 'John' },
+                pretty: true,
+            });
+            expect(result.text).toContain('\n');
+            expect(result.text).toContain('  ');
+        });
+    });
+    describe('parseCsv', () => {
+        it('has correct metadata', () => {
+            expect(parseCsv.id).toBe('data.csv.parse');
+            expect(parseCsv.category).toBe('data');
+        });
+        it('parses CSV with headers', async () => {
+            const result = await parseCsv.handler({
+                text: 'name,age\nJohn,30\nJane,25',
+            });
+            expect(result.headers).toEqual(['name', 'age']);
+            expect(result.rows).toHaveLength(2);
+            expect(result.rows[0]).toEqual({ name: 'John', age: '30' });
+        });
+        it('parses CSV without headers', async () => {
+            const result = await parseCsv.handler({
+                text: 'John,30\nJane,25',
+                hasHeaders: false,
+            });
+            expect(result.headers).toEqual(['column1', 'column2']);
+            expect(result.rows).toHaveLength(2);
+        });
+        it('supports custom delimiter', async () => {
+            const result = await parseCsv.handler({
+                text: 'name;age\nJohn;30',
+                delimiter: ';',
+            });
+            expect(result.rows[0]).toEqual({ name: 'John', age: '30' });
+        });
+        it('handles empty input', async () => {
+            const result = await parseCsv.handler({
+                text: '',
+            });
+            expect(result.rows).toHaveLength(0);
+            expect(result.rowCount).toBe(0);
+        });
+    });
+    describe('transformData', () => {
+        it('has correct metadata', () => {
+            expect(transformData.id).toBe('data.transform');
+            expect(transformData.category).toBe('data');
+        });
+        it('transforms data with field mapping', async () => {
+            const result = await transformData.handler({
+                data: {
+                    user: {
+                        firstName: 'John',
+                        lastName: 'Doe',
+                    },
+                    email: 'john@example.com',
+                },
+                transform: {
+                    name: 'user.firstName',
+                    contact: 'email',
+                },
+            });
+            expect(result.result).toEqual({
+                name: 'John',
+                contact: 'john@example.com',
+            });
+        });
+        it('handles nested paths', async () => {
+            const result = await transformData.handler({
+                data: { a: { b: { c: 'deep' } } },
+                transform: { value: 'a.b.c' },
+            });
+            expect(result.result.value).toBe('deep');
+        });
+        it('handles missing paths', async () => {
+            const result = await transformData.handler({
+                data: { a: 1 },
+                transform: { value: 'b.c.d' },
+            });
+            expect(result.result.value).toBeUndefined();
+        });
+    });
+    describe('filterData', () => {
+        it('has correct metadata', () => {
+            expect(filterData.id).toBe('data.filter');
+            expect(filterData.category).toBe('data');
+        });
+        it('filters array by criteria', async () => {
+            const result = await filterData.handler({
+                data: [
+                    { name: 'John', status: 'active' },
+                    { name: 'Jane', status: 'inactive' },
+                    { name: 'Bob', status: 'active' },
+                ],
+                filter: { status: 'active' },
+            });
+            expect(result.results).toHaveLength(2);
+            expect(result.count).toBe(2);
+        });
+        it('handles multiple filter criteria', async () => {
+            const result = await filterData.handler({
+                data: [
+                    { name: 'John', status: 'active', role: 'admin' },
+                    { name: 'Jane', status: 'active', role: 'user' },
+                    { name: 'Bob', status: 'inactive', role: 'admin' },
+                ],
+                filter: { status: 'active', role: 'admin' },
+            });
+            expect(result.results).toHaveLength(1);
+            expect(result.results[0]).toEqual({ name: 'John', status: 'active', role: 'admin' });
+        });
+        it('returns empty for no matches', async () => {
+            const result = await filterData.handler({
+                data: [{ a: 1 }, { a: 2 }],
+                filter: { a: 3 },
+            });
+            expect(result.results).toHaveLength(0);
+        });
+    });
+    describe('dataTools array', () => {
+        it('contains all data tools', () => {
+            expect(dataTools).toHaveLength(5);
+            const ids = dataTools.map(t => t.id);
+            expect(ids).toContain('data.json.parse');
+            expect(ids).toContain('data.json.stringify');
+            expect(ids).toContain('data.csv.parse');
+            expect(ids).toContain('data.transform');
+            expect(ids).toContain('data.filter');
+        });
+    });
+});
+describe('Communication Tools', () => {
+    describe('sendEmail', () => {
+        it('has correct metadata', () => {
+            expect(sendEmail.id).toBe('communication.email.send');
+            expect(sendEmail.category).toBe('communication');
+            expect(sendEmail.subcategory).toBe('email');
+        });
+        it('has required parameters', () => {
+            const toParam = sendEmail.parameters.find(p => p.name === 'to');
+            const subjectParam = sendEmail.parameters.find(p => p.name === 'subject');
+            const bodyParam = sendEmail.parameters.find(p => p.name === 'body');
+            expect(toParam?.required).toBe(true);
+            expect(subjectParam?.required).toBe(true);
+            expect(bodyParam?.required).toBe(true);
+        });
+        it('requires confirmation', () => {
+            expect(sendEmail.requiresConfirmation).toBe(true);
+        });
+        it('has permissions', () => {
+            expect(sendEmail.permissions).toBeDefined();
+            expect(sendEmail.permissions?.[0]?.resource).toBe('email');
+        });
+        it('simulates sending email', async () => {
+            const result = await sendEmail.handler({
+                to: ['test@example.com'],
+                subject: 'Test',
+                body: 'Test body',
+            });
+            expect(result.success).toBe(true);
+            expect(result.messageId).toBeDefined();
+        });
+    });
+    describe('sendSlackMessage', () => {
+        it('has correct metadata', () => {
+            expect(sendSlackMessage.id).toBe('communication.slack.send');
+            expect(sendSlackMessage.category).toBe('communication');
+            expect(sendSlackMessage.subcategory).toBe('slack');
+        });
+        it('simulates sending message', async () => {
+            const result = await sendSlackMessage.handler({
+                channel: '#general',
+                text: 'Hello Slack!',
+            });
+            expect(result.success).toBe(true);
+            expect(result.ts).toBeDefined();
+            expect(result.channel).toBe('#general');
+        });
+    });
+    describe('sendNotification', () => {
+        it('has correct metadata', () => {
+            expect(sendNotification.id).toBe('communication.notify');
+            expect(sendNotification.category).toBe('communication');
+            expect(sendNotification.subcategory).toBe('notification');
+        });
+        it('simulates sending notification', async () => {
+            const result = await sendNotification.handler({
+                channel: 'email',
+                recipients: ['user@example.com'],
+                title: 'Alert',
+                message: 'This is an alert',
+                priority: 'high',
+            });
+            expect(result.success).toBe(true);
+            expect(result.notificationId).toBeDefined();
+            expect(result.delivered).toContain('user@example.com');
+        });
+    });
+    describe('sendSms', () => {
+        it('has correct metadata', () => {
+            expect(sendSms.id).toBe('communication.sms.send');
+            expect(sendSms.category).toBe('communication');
+            expect(sendSms.subcategory).toBe('sms');
+        });
+        it('requires confirmation', () => {
+            expect(sendSms.requiresConfirmation).toBe(true);
+        });
+        it('simulates sending SMS', async () => {
+            const result = await sendSms.handler({
+                to: '+15551234567',
+                message: 'Test SMS',
+            });
+            expect(result.success).toBe(true);
+            expect(result.messageId).toBeDefined();
+        });
+    });
+    describe('communicationTools array', () => {
+        it('contains all communication tools', () => {
+            expect(communicationTools).toHaveLength(4);
+            const ids = communicationTools.map(t => t.id);
+            expect(ids).toContain('communication.email.send');
+            expect(ids).toContain('communication.slack.send');
+            expect(ids).toContain('communication.notify');
+            expect(ids).toContain('communication.sms.send');
+        });
+    });
+});
+describe('Builtin Tools Utilities', () => {
+    beforeEach(() => {
+        registry.clear();
+    });
+    describe('getBuiltinTools', () => {
+        it('returns all builtin tools', () => {
+            const tools = getBuiltinTools();
+            expect(tools.length).toBe(webTools.length + dataTools.length + communicationTools.length);
+        });
+    });
+    describe('registerBuiltinTools', () => {
+        it('registers all builtin tools in registry', () => {
+            registerBuiltinTools();
+            expect(registry.has('web.fetch')).toBe(true);
+            expect(registry.has('data.json.parse')).toBe(true);
+            expect(registry.has('communication.email.send')).toBe(true);
+        });
+    });
+});