stigmergy 1.0.93 → 1.0.95

package/test/hash-table-test.js

@@ -0,0 +1,26 @@
+const { HashTable } = require('../src/utils');
+
+// Create a new hash table
+const ht = new HashTable(17);
+
+// Test setting values
+ht.set("maroon", "#800000");
+ht.set("yellow", "#FFFF00");
+ht.set("olive", "#808000");
+ht.set("salmon", "#FA8072");
+ht.set("lightcoral", "#F08080");
+ht.set("mediumvioletred", "#C71585");
+ht.set("plum", "#DDA0DD");
+
+// Test getting values
+console.log(ht.get("maroon")); // #800000
+console.log(ht.get("yellow")); // #FFFF00
+console.log(ht.get("invalid")); // undefined
+
+// Test keys method
+console.log(ht.keys()); 
+
+// Test values method
+console.log(ht.values());
+
+console.log("Hash table tests completed successfully!");

package/test/json-validation-test.js

@@ -0,0 +1,164 @@
+const { parseAndValidateJSON } = require('../src/utils');
+
+// Test cases for parseAndValidateJSON function
+console.log('Testing parseAndValidateJSON function...\n');
+
+// Test 1: Valid JSON without schema
+try {
+  const jsonData = '{"name": "John", "age": 30}';
+  const result = parseAndValidateJSON(jsonData);
+  console.log('Test 1 passed: Valid JSON parsed successfully');
+  console.log('Result:', result);
+} catch (error) {
+  console.log('Test 1 failed:', error.message);
+}
+
+console.log();
+
+// Test 2: Invalid JSON
+try {
+  const invalidJson = '{"name": "John", "age":}';
+  const result = parseAndValidateJSON(invalidJson);
+  console.log('Test 2 failed: Should have thrown an error');
+} catch (error) {
+  console.log('Test 2 passed: Correctly rejected invalid JSON');
+  console.log('Error:', error.message);
+}
+
+console.log();
+
+// Test 3: Valid JSON with schema validation
+try {
+  const jsonData = '{"name": "John", "age": 30, "active": true}';
+  const schema = {
+    required: ['name', 'age'],
+    properties: {
+      name: { type: 'string' },
+      age: { type: 'number' },
+      active: { type: 'boolean' }
+    }
+  };
+  const result = parseAndValidateJSON(jsonData, schema);
+  console.log('Test 3 passed: Valid JSON with schema validation');
+  console.log('Result:', result);
+} catch (error) {
+  console.log('Test 3 failed:', error.message);
+}
+
+console.log();
+
+// Test 4: Missing required field
+try {
+  const jsonData = '{"name": "John"}';
+  const schema = {
+    required: ['name', 'age'],
+    properties: {
+      name: { type: 'string' },
+      age: { type: 'number' }
+    }
+  };
+  const result = parseAndValidateJSON(jsonData, schema);
+  console.log('Test 4 failed: Should have thrown an error for missing required field');
+} catch (error) {
+  console.log('Test 4 passed: Correctly rejected missing required field');
+  console.log('Error:', error.message);
+}
+
+console.log();
+
+// Test 5: Wrong data type
+try {
+  const jsonData = '{"name": "John", "age": "thirty"}';
+  const schema = {
+    required: ['name', 'age'],
+    properties: {
+      name: { type: 'string' },
+      age: { type: 'number' }
+    }
+  };
+  const result = parseAndValidateJSON(jsonData, schema);
+  console.log('Test 5 failed: Should have thrown an error for wrong data type');
+} catch (error) {
+  console.log('Test 5 passed: Correctly rejected wrong data type');
+  console.log('Error:', error.message);
+}
+
+console.log();
+
+// Test 6: Enum validation
+try {
+  const jsonData = '{"status": "active"}';
+  const schema = {
+    required: ['status'],
+    properties: {
+      status: { type: 'string', enum: ['active', 'inactive', 'pending'] }
+    }
+  };
+  const result = parseAndValidateJSON(jsonData, schema);
+  console.log('Test 6 passed: Valid enum value accepted');
+  console.log('Result:', result);
+} catch (error) {
+  console.log('Test 6 failed:', error.message);
+}
+
+console.log();
+
+// Test 7: Invalid enum value
+try {
+  const jsonData = '{"status": "deleted"}';
+  const schema = {
+    required: ['status'],
+    properties: {
+      status: { type: 'string', enum: ['active', 'inactive', 'pending'] }
+    }
+  };
+  const result = parseAndValidateJSON(jsonData, schema);
+  console.log('Test 7 failed: Should have thrown an error for invalid enum value');
+} catch (error) {
+  console.log('Test 7 passed: Correctly rejected invalid enum value');
+  console.log('Error:', error.message);
+}
+
+console.log();
+
+// Test 8: Array validation
+try {
+  const jsonData = '{"tags": ["javascript", "nodejs"]}';
+  const schema = {
+    required: ['tags'],
+    properties: {
+      tags: { 
+        type: 'array',
+        items: { type: 'string' }
+      }
+    }
+  };
+  const result = parseAndValidateJSON(jsonData, schema);
+  console.log('Test 8 passed: Valid array accepted');
+  console.log('Result:', result);
+} catch (error) {
+  console.log('Test 8 failed:', error.message);
+}
+
+console.log();
+
+// Test 9: Invalid array items
+try {
+  const jsonData = '{"tags": ["javascript", 123]}';
+  const schema = {
+    required: ['tags'],
+    properties: {
+      tags: { 
+        type: 'array',
+        items: { type: 'string' }
+      }
+    }
+  };
+  const result = parseAndValidateJSON(jsonData, schema);
+  console.log('Test 9 failed: Should have thrown an error for invalid array items');
+} catch (error) {
+  console.log('Test 9 passed: Correctly rejected invalid array items');
+  console.log('Error:', error.message);
+}
+
+console.log('\nAll tests completed!');

package/test/rest-client-test.js

@@ -0,0 +1,56 @@
+const { RESTClient } = require('../src/utils');
+
+async function testRESTClient() {
+  console.log('Testing REST API Client...\n');
+  
+  // Test with a public API
+  const client = new RESTClient('https://jsonplaceholder.typicode.com');
+  
+  try {
+    // Test GET request
+    console.log('1. Testing GET request...');
+    const getResponse = await client.get('/posts/1');
+    console.log('GET Response Status:', getResponse.status);
+    console.log('GET Response Data Title:', getResponse.data.title);
+    console.log('-------------------\n');
+    
+    // Test POST request
+    console.log('2. Testing POST request...');
+    const postData = {
+      title: 'Test Post',
+      body: 'This is a test post',
+      userId: 1
+    };
+    const postResponse = await client.post('/posts', postData);
+    console.log('POST Response Status:', postResponse.status);
+    console.log('POST Response Data ID:', postResponse.data.id);
+    console.log('-------------------\n');
+    
+    // Test PUT request
+    console.log('3. Testing PUT request...');
+    const putData = {
+      id: 1,
+      title: 'Updated Post',
+      body: 'This post has been updated',
+      userId: 1
+    };
+    const putResponse = await client.put('/posts/1', putData);
+    console.log('PUT Response Status:', putResponse.status);
+    console.log('PUT Response Data Title:', putResponse.data.title);
+    console.log('-------------------\n');
+    
+    // Test DELETE request
+    console.log('4. Testing DELETE request...');
+    const deleteResponse = await client.delete('/posts/1');
+    console.log('DELETE Response Status:', deleteResponse.status);
+    console.log('DELETE Request completed successfully');
+    console.log('-------------------\n');
+    
+    console.log('All tests passed!');
+  } catch (error) {
+    console.error('Test failed:', error.message);
+  }
+}
+
+// Run the test
+testRESTClient();

package/test/unit/calculator-full.test.js

@@ -0,0 +1,191 @@
+/**
+ * Unit tests for Calculator class following project patterns
+ */
+
+const assert = require('assert');
+const Calculator = require('../../src/calculator');
+
+describe('Calculator Unit Tests', () => {
+    let calc;
+
+    beforeEach(() => {
+        calc = new Calculator();
+    });
+
+    describe('Basic Arithmetic Operations', () => {
+        it('should add two numbers correctly', () => {
+            assert.strictEqual(calc.add(5, 3), 8);
+            assert.strictEqual(calc.add(-2, 7), 5);
+            assert.strictEqual(calc.add(0, 0), 0);
+            assert.strictEqual(calc.add(1.5, 2.5), 4);
+        });
+
+        it('should subtract two numbers correctly', () => {
+            assert.strictEqual(calc.subtract(10, 4), 6);
+            assert.strictEqual(calc.subtract(5, 8), -3);
+            assert.strictEqual(calc.subtract(0, 0), 0);
+            assert.strictEqual(calc.subtract(3.5, 1.5), 2);
+        });
+
+        it('should multiply two numbers correctly', () => {
+            assert.strictEqual(calc.multiply(6, 7), 42);
+            assert.strictEqual(calc.multiply(-3, 4), -12);
+            assert.strictEqual(calc.multiply(0, 100), 0);
+            assert.strictEqual(calc.multiply(2.5, 4), 10);
+        });
+
+        it('should divide two numbers correctly', () => {
+            assert.strictEqual(calc.divide(15, 3), 5);
+            assert.strictEqual(calc.divide(7, 2), 3.5);
+            assert.strictEqual(calc.divide(-10, 2), -5);
+            assert.strictEqual(calc.divide(1, 3), 1/3);
+        });
+
+        it('should throw error when dividing by zero', () => {
+            assert.throws(() => calc.divide(10, 0), {
+                name: 'Error',
+                message: 'Cannot divide by zero'
+            });
+        });
+    });
+
+    describe('Advanced Mathematical Operations', () => {
+        it('should calculate power correctly', () => {
+            assert.strictEqual(calc.power(2, 3), 8);
+            assert.strictEqual(calc.power(5, 0), 1);
+            assert.strictEqual(calc.power(10, 2), 100);
+            assert.strictEqual(calc.power(4, 0.5), 2);
+        });
+
+        it('should calculate square root correctly', () => {
+            assert.strictEqual(calc.sqrt(16), 4);
+            assert.strictEqual(calc.sqrt(0), 0);
+            assert.strictEqual(calc.sqrt(1), 1);
+            assert.strictEqual(calc.sqrt(2), Math.sqrt(2));
+        });
+
+        it('should throw error when calculating square root of negative number', () => {
+            assert.throws(() => calc.sqrt(-4), {
+                name: 'Error',
+                message: 'Cannot calculate square root of negative number'
+            });
+        });
+
+        it('should calculate factorial correctly', () => {
+            assert.strictEqual(calc.factorial(5), 120);
+            assert.strictEqual(calc.factorial(0), 1);
+            assert.strictEqual(calc.factorial(1), 1);
+            assert.strictEqual(calc.factorial(3), 6);
+        });
+
+        it('should throw error when calculating factorial of negative number', () => {
+            assert.throws(() => calc.factorial(-5), {
+                name: 'Error',
+                message: 'Cannot calculate factorial of negative number'
+            });
+        });
+
+        it('should calculate percentage correctly', () => {
+            assert.strictEqual(calc.percentage(25, 100), 25);
+            assert.strictEqual(calc.percentage(10, 50), 20);
+            assert.strictEqual(calc.percentage(0, 100), 0);
+            assert.strictEqual(calc.percentage(75, 150), 50);
+        });
+
+        it('should throw error when calculating percentage with zero as whole', () => {
+            assert.throws(() => calc.percentage(50, 0), {
+                name: 'Error',
+                message: 'Cannot calculate percentage with zero as whole'
+            });
+        });
+    });
+
+    describe('Calculation Chain', () => {
+        it('should chain calculations correctly', () => {
+            const result = calc.chain(10).add(5).multiply(2).subtract(4).divide(2).equals();
+            // ((10 + 5) * 2 - 4) / 2 = (30 - 4) / 2 = 26 / 2 = 13
+            assert.strictEqual(result, 13);
+        });
+
+        it('should throw error when dividing by zero in chain', () => {
+            assert.throws(() => calc.chain(10).divide(0), {
+                name: 'Error',
+                message: 'Cannot divide by zero'
+            });
+        });
+
+        it('should return current value without ending chain', () => {
+            const chain = calc.chain(5).add(3);
+            assert.strictEqual(chain.value(), 8);
+        });
+
+        it('should support method chaining', () => {
+            const chain = calc.chain(2);
+            assert.strictEqual(chain.add(3), chain); // Should return itself for chaining
+            assert.strictEqual(chain.subtract(1), chain);
+            assert.strictEqual(chain.multiply(2), chain);
+            assert.strictEqual(chain.divide(2), chain);
+            assert.strictEqual(chain.power(2), chain);
+        });
+    });
+});
+
+// Run tests directly if this file is executed
+if (require.main === module) {
+    console.log('Running Calculator Unit Tests...');
+    
+    const calc = new Calculator();
+    
+    // Test basic operations
+    console.log('\n1. Testing basic arithmetic operations:');
+    console.log('calc.add(5, 3) =', calc.add(5, 3));
+    console.log('calc.subtract(10, 4) =', calc.subtract(10, 4));
+    console.log('calc.multiply(6, 7) =', calc.multiply(6, 7));
+    console.log('calc.divide(15, 3) =', calc.divide(15, 3));
+    
+    // Test advanced operations
+    console.log('\n2. Testing advanced mathematical operations:');
+    console.log('calc.power(2, 3) =', calc.power(2, 3));
+    console.log('calc.sqrt(16) =', calc.sqrt(16));
+    console.log('calc.factorial(5) =', calc.factorial(5));
+    console.log('calc.percentage(25, 100) =', calc.percentage(25, 100) + '%');
+    
+    // Test calculation chain
+    console.log('\n3. Testing calculation chain:');
+    const chainResult = calc.chain(10).add(5).multiply(2).subtract(4).divide(2).equals();
+    console.log('calc.chain(10).add(5).multiply(2).subtract(4).divide(2).equals() =', chainResult);
+    
+    // Test error cases
+    console.log('\n4. Testing error handling:');
+    try {
+        calc.divide(10, 0);
+    } catch (error) {
+        console.log('Division by zero error:', error.message);
+    }
+    
+    try {
+        calc.sqrt(-4);
+    } catch (error) {
+        console.log('Square root of negative number error:', error.message);
+    }
+    
+    try {
+        calc.factorial(-5);
+    } catch (error) {
+        console.log('Factorial of negative number error:', error.message);
+    }
+    
+    try {
+        calc.percentage(50, 0);
+    } catch (error) {
+        console.log('Percentage with zero as whole error:', error.message);
+    }
+    
+    try {
+        calc.chain(10).divide(0);
+    } catch (error) {
+        console.log('Chain division by zero error:', error.message);
+    }
+    
+    console.log('\n✅ All Calculator tests completed!');
+}

package/test/unit/calculator-simple.test.js

@@ -0,0 +1,96 @@
+/**
+ * Simple unit tests for Calculator class
+ */
+
+const Calculator = require('../../src/calculator');
+
+console.log("Testing Calculator class...");
+
+const calc = new Calculator();
+
+try {
+  // Test basic operations
+  console.log("\n1. Testing basic arithmetic operations:");
+  
+  // Addition
+  const sum = calc.add(5, 3);
+  console.log(`calc.add(5, 3) = ${sum}`);
+  
+  // Subtraction
+  const difference = calc.subtract(10, 4);
+  console.log(`calc.subtract(10, 4) = ${difference}`);
+  
+  // Multiplication
+  const product = calc.multiply(6, 7);
+  console.log(`calc.multiply(6, 7) = ${product}`);
+  
+  // Division
+  const quotient = calc.divide(15, 3);
+  console.log(`calc.divide(15, 3) = ${quotient}`);
+  
+  // Power
+  const powerResult = calc.power(2, 3);
+  console.log(`calc.power(2, 3) = ${powerResult}`);
+  
+  // Square root
+  const sqrtResult = calc.sqrt(16);
+  console.log(`calc.sqrt(16) = ${sqrtResult}`);
+  
+  // Factorial
+  const factorialResult = calc.factorial(5);
+  console.log(`calc.factorial(5) = ${factorialResult}`);
+  
+  // Percentage
+  const percentageResult = calc.percentage(25, 100);
+  console.log(`calc.percentage(25, 100) = ${percentageResult}%`);
+  
+  console.log("\n✅ Basic operations tests passed!");
+
+  // Test calculation chain
+  console.log("\n2. Testing calculation chain:");
+  const chainResult = calc.chain(10).add(5).multiply(2).subtract(4).divide(2).equals();
+  console.log(`calc.chain(10).add(5).multiply(2).subtract(4).divide(2).equals() = ${chainResult}`);
+  console.log("✅ Chain operations test passed!");
+  
+  console.log("\n✅ All tests passed!");
+} catch (error) {
+  console.error("❌ Test failed:", error.message);
+}
+
+// Test error cases
+console.log("\n3. Testing error handling:");
+
+try {
+  calc.divide(10, 0);
+  console.log("❌ Should have thrown an error for division by zero");
+} catch (error) {
+  console.log("✅ Correctly threw error for division by zero:", error.message);
+}
+
+try {
+  calc.sqrt(-4);
+  console.log("❌ Should have thrown an error for square root of negative number");
+} catch (error) {
+  console.log("✅ Correctly threw error for square root of negative number:", error.message);
+}
+
+try {
+  calc.factorial(-5);
+  console.log("❌ Should have thrown an error for factorial of negative number");
+} catch (error) {
+  console.log("✅ Correctly threw error for factorial of negative number:", error.message);
+}
+
+try {
+  calc.percentage(50, 0);
+  console.log("❌ Should have thrown an error for percentage with zero as whole");
+} catch (error) {
+  console.log("✅ Correctly threw error for percentage with zero as whole:", error.message);
+}
+
+try {
+  calc.chain(10).divide(0);
+  console.log("❌ Should have thrown an error for chain division by zero");
+} catch (error) {
+  console.log("✅ Correctly threw error for chain division by zero:", error.message);
+}

package/test/unit/calculator.test.js

@@ -0,0 +1,97 @@
+/**
+ * Unit tests for Calculator class following project patterns
+ */
+
+const Calculator = require('../../src/calculator');
+
+// Test suite for Calculator
+describe('Calculator', () => {
+  let calc;
+
+  beforeEach(() => {
+    calc = new Calculator();
+  });
+
+  describe('Basic Operations', () => {
+    test('should add two numbers correctly', () => {
+      expect(calc.add(5, 3)).toBe(8);
+      expect(calc.add(-2, 7)).toBe(5);
+      expect(calc.add(0, 0)).toBe(0);
+    });
+
+    test('should subtract two numbers correctly', () => {
+      expect(calc.subtract(10, 4)).toBe(6);
+      expect(calc.subtract(5, 8)).toBe(-3);
+      expect(calc.subtract(0, 0)).toBe(0);
+    });
+
+    test('should multiply two numbers correctly', () => {
+      expect(calc.multiply(6, 7)).toBe(42);
+      expect(calc.multiply(-3, 4)).toBe(-12);
+      expect(calc.multiply(0, 100)).toBe(0);
+    });
+
+    test('should divide two numbers correctly', () => {
+      expect(calc.divide(15, 3)).toBe(5);
+      expect(calc.divide(7, 2)).toBe(3.5);
+      expect(calc.divide(-10, 2)).toBe(-5);
+    });
+
+    test('should throw error when dividing by zero', () => {
+      expect(() => calc.divide(10, 0)).toThrow('Cannot divide by zero');
+    });
+
+    test('should calculate power correctly', () => {
+      expect(calc.power(2, 3)).toBe(8);
+      expect(calc.power(5, 0)).toBe(1);
+      expect(calc.power(10, 2)).toBe(100);
+    });
+
+    test('should calculate square root correctly', () => {
+      expect(calc.sqrt(16)).toBe(4);
+      expect(calc.sqrt(0)).toBe(0);
+      expect(calc.sqrt(1)).toBe(1);
+    });
+
+    test('should throw error when calculating square root of negative number', () => {
+      expect(() => calc.sqrt(-4)).toThrow('Cannot calculate square root of negative number');
+    });
+
+    test('should calculate factorial correctly', () => {
+      expect(calc.factorial(5)).toBe(120);
+      expect(calc.factorial(0)).toBe(1);
+      expect(calc.factorial(1)).toBe(1);
+    });
+
+    test('should throw error when calculating factorial of negative number', () => {
+      expect(() => calc.factorial(-5)).toThrow('Cannot calculate factorial of negative number');
+    });
+
+    test('should calculate percentage correctly', () => {
+      expect(calc.percentage(25, 100)).toBe(25);
+      expect(calc.percentage(10, 50)).toBe(20);
+      expect(calc.percentage(0, 100)).toBe(0);
+    });
+
+    test('should throw error when calculating percentage with zero as whole', () => {
+      expect(() => calc.percentage(50, 0)).toThrow('Cannot calculate percentage with zero as whole');
+    });
+  });
+
+  describe('Calculation Chain', () => {
+    test('should chain calculations correctly', () => {
+      const result = calc.chain(10).add(5).multiply(2).subtract(4).divide(2).equals();
+      // ((10 + 5) * 2 - 4) / 2 = (30 - 4) / 2 = 26 / 2 = 13
+      expect(result).toBe(13);
+    });
+
+    test('should throw error when dividing by zero in chain', () => {
+      expect(() => calc.chain(10).divide(0)).toThrow('Cannot divide by zero');
+    });
+
+    test('should return current value without ending chain', () => {
+      const chain = calc.chain(5).add(3);
+      expect(chain.value()).toBe(8);
+    });
+  });
+});