calc-mcp-server 0.1.0

package/test/integration/basic-calculate.test.ts

@@ -0,0 +1,272 @@
+import { describe, it, expect } from 'vitest';
+import { basicCalculate } from '../../src/mcp/tools/basic.js';
+
+describe('basicCalculate', () => {
+  describe('Basic arithmetic operations', () => {
+    it('should add two numbers', () => {
+      const result = basicCalculate({ expression: '2 + 3' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('5');
+        expect(result.details?.expression).toBe('2 + 3');
+      }
+    });
+
+    it('should subtract two numbers', () => {
+      const result = basicCalculate({ expression: '10 - 4' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('6');
+      }
+    });
+
+    it('should multiply two numbers', () => {
+      const result = basicCalculate({ expression: '6 * 7' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('42');
+      }
+    });
+
+    it('should divide two numbers', () => {
+      const result = basicCalculate({ expression: '15 / 3' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('5');
+      }
+    });
+
+    it('should calculate modulo', () => {
+      const result = basicCalculate({ expression: '17 % 5' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('2');
+      }
+    });
+  });
+
+  describe('Floating point arithmetic', () => {
+    it('should handle 0.1 + 0.2 correctly', () => {
+      const result = basicCalculate({ expression: '0.1 + 0.2' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('0.3');
+      }
+    });
+
+    it('should handle 1 / 3 with decimal precision', () => {
+      const result = basicCalculate({ expression: '1 / 3' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(parseFloat(result.result)).toBeCloseTo(0.333, 2);
+      }
+    });
+
+    it('should handle 3.14159 * 2', () => {
+      const result = basicCalculate({ expression: '3.14159 * 2' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('6.28318');
+      }
+    });
+  });
+
+  describe('Operator precedence', () => {
+    it('should respect multiplication before addition', () => {
+      const result = basicCalculate({ expression: '2 + 3 * 4' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('14');
+      }
+    });
+
+    it('should respect parentheses', () => {
+      const result = basicCalculate({ expression: '(2 + 3) * 4' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('20');
+      }
+    });
+
+    it('should handle nested parentheses', () => {
+      const result = basicCalculate({ expression: '((2 + 3) * (4 - 1)) / 5' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('3');
+      }
+    });
+  });
+
+  describe('Complex expressions', () => {
+    it('should handle 2.5 * 3 + (10 - 4) / 2', () => {
+      const result = basicCalculate({ expression: '2.5 * 3 + (10 - 4) / 2' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('10.5');
+      }
+    });
+
+    it('should handle (10 + 5) * (8 - 3) / 5', () => {
+      const result = basicCalculate({ expression: '(10 + 5) * (8 - 3) / 5' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('15');
+      }
+    });
+
+    it('should handle 100 / 4 / 5', () => {
+      const result = basicCalculate({ expression: '100 / 4 / 5' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('5');
+      }
+    });
+  });
+
+  describe('Negative numbers', () => {
+    it('should handle -5 + 3', () => {
+      const result = basicCalculate({ expression: '-5 + 3' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('-2');
+      }
+    });
+
+    it('should handle -10 * -2', () => {
+      const result = basicCalculate({ expression: '-10 * -2' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('20');
+      }
+    });
+
+    it('should handle 5 + -3', () => {
+      const result = basicCalculate({ expression: '5 + -3' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('2');
+      }
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should return error for empty expression', () => {
+      const result = basicCalculate({ expression: '' });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('EmptyInput');
+      }
+    });
+
+    it('should return error for whitespace only', () => {
+      const result = basicCalculate({ expression: '   ' });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('EmptyInput');
+      }
+    });
+
+    it('should return error for division by zero', () => {
+      const result = basicCalculate({ expression: '5 / 0' });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('DivisionByZero');
+      }
+    });
+
+    it('should return error for modulo by zero', () => {
+      const result = basicCalculate({ expression: '5 % 0' });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('DivisionByZero');
+      }
+    });
+
+    it('should return error for unmatched opening parenthesis', () => {
+      const result = basicCalculate({ expression: '(2 + 3' });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('SyntaxError');
+        expect(result.error.message).toContain('Unmatched');
+      }
+    });
+
+    it('should return error for unmatched closing parenthesis', () => {
+      const result = basicCalculate({ expression: '2 + 3)' });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('SyntaxError');
+      }
+    });
+
+    it('should return error for invalid expression', () => {
+      const result = basicCalculate({ expression: '2 + + 3' });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('SyntaxError');
+      }
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle 0 + 0', () => {
+      const result = basicCalculate({ expression: '0 + 0' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('0');
+      }
+    });
+
+    it('should handle single number', () => {
+      const result = basicCalculate({ expression: '42' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('42');
+      }
+    });
+
+    it('should handle expression with whitespace', () => {
+      const result = basicCalculate({ expression: '  2   +   3  ' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('5');
+      }
+    });
+
+    it('should handle very large numbers', () => {
+      const result = basicCalculate({ expression: '999999999 * 999999999' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('999999998000000001');
+      }
+    });
+  });
+});

package/test/integration/conversion.test.ts

@@ -0,0 +1,357 @@
+import { describe, it, expect } from 'vitest';
+import { convertBase } from '../../src/mcp/tools/conversion.js';
+
+describe('convertBase', () => {
+  describe('Binary conversions (base 2)', () => {
+    it('should convert binary to decimal', () => {
+      const result = convertBase({ value: '1010', fromBase: 2, toBase: 10 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('10');
+      }
+    });
+
+    it('should convert binary to hexadecimal', () => {
+      const result = convertBase({ value: '11111111', fromBase: 2, toBase: 16 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('FF');
+      }
+    });
+
+    it('should convert binary to octal', () => {
+      const result = convertBase({ value: '101010', fromBase: 2, toBase: 8 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('52');
+      }
+    });
+
+    it('should convert binary to binary (identity)', () => {
+      const result = convertBase({ value: '1100100', fromBase: 2, toBase: 2 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('1100100');
+      }
+    });
+  });
+
+  describe('Octal conversions (base 8)', () => {
+    it('should convert octal to decimal', () => {
+      const result = convertBase({ value: '755', fromBase: 8, toBase: 10 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('493');
+      }
+    });
+
+    it('should convert octal to binary', () => {
+      const result = convertBase({ value: '10', fromBase: 8, toBase: 2 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('1000');
+      }
+    });
+
+    it('should convert octal to hexadecimal', () => {
+      const result = convertBase({ value: '377', fromBase: 8, toBase: 16 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('FF');
+      }
+    });
+
+    it('should convert octal to octal (identity)', () => {
+      const result = convertBase({ value: '12345670', fromBase: 8, toBase: 8 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('12345670');
+      }
+    });
+  });
+
+  describe('Decimal conversions (base 10)', () => {
+    it('should convert decimal to binary', () => {
+      const result = convertBase({ value: '42', fromBase: 10, toBase: 2 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('101010');
+      }
+    });
+
+    it('should convert decimal to hexadecimal', () => {
+      const result = convertBase({ value: '255', fromBase: 10, toBase: 16 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('FF');
+      }
+    });
+
+    it('should convert decimal to octal', () => {
+      const result = convertBase({ value: '64', fromBase: 10, toBase: 8 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('100');
+      }
+    });
+
+    it('should convert decimal to decimal (identity)', () => {
+      const result = convertBase({ value: '12345', fromBase: 10, toBase: 10 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('12345');
+      }
+    });
+
+    it('should handle negative decimal numbers', () => {
+      const result = convertBase({ value: '-42', fromBase: 10, toBase: 16 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('2A');
+      }
+    });
+  });
+
+  describe('Hexadecimal conversions (base 16)', () => {
+    it('should convert hex to decimal', () => {
+      const result = convertBase({ value: 'FF', fromBase: 16, toBase: 10 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('255');
+      }
+    });
+
+    it('should convert hex to binary', () => {
+      const result = convertBase({ value: 'A', fromBase: 16, toBase: 2 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('1010');
+      }
+    });
+
+    it('should convert hex to octal', () => {
+      const result = convertBase({ value: '10', fromBase: 16, toBase: 8 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('20');
+      }
+    });
+
+    it('should convert hex to hex (identity)', () => {
+      const result = convertBase({ value: 'ABCDEF', fromBase: 16, toBase: 16 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('ABCDEF');
+      }
+    });
+
+    it('should handle lowercase hex input', () => {
+      const result = convertBase({ value: 'ff', fromBase: 16, toBase: 10 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('255');
+      }
+    });
+
+    it('should output uppercase hex', () => {
+      const result = convertBase({ value: 'ff', fromBase: 16, toBase: 16 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('FF');
+      }
+    });
+  });
+
+  describe('Large number conversions', () => {
+    it('should convert large decimal to hex', () => {
+      const result = convertBase({ value: '4294967295', fromBase: 10, toBase: 16 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('FFFFFFFF');
+      }
+    });
+
+    it('should convert large hex to decimal', () => {
+      const result = convertBase({ value: 'FFFFFFFF', fromBase: 16, toBase: 10 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('4294967295');
+      }
+    });
+
+    it('should convert large binary to hex', () => {
+      const result = convertBase({ value: '11111111111111111111111111111111', fromBase: 2, toBase: 16 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('FFFFFFFF');
+      }
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle zero in all bases', () => {
+      const bases = [2, 8, 10, 16];
+      for (const fromBase of bases) {
+        for (const toBase of bases) {
+          const result = convertBase({ value: '0', fromBase, toBase });
+          expect(result.success).toBe(true);
+          if (result.success) {
+            expect(result.result).toBe('0');
+          }
+        }
+      }
+    });
+
+    it('should handle single digit conversions', () => {
+      const result = convertBase({ value: '7', fromBase: 10, toBase: 2 });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('111');
+      }
+    });
+
+    it('should include steps in details', () => {
+      const result = convertBase({ value: 'FF', fromBase: 16, toBase: 10 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.details?.steps).toBeDefined();
+        expect(result.details?.steps?.length).toBe(3);
+        expect(result.details?.steps?.[0]).toContain('FF');
+        expect(result.details?.steps?.[1]).toContain('255');
+        expect(result.details?.steps?.[2]).toContain('base 10');
+      }
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should return error for empty value', () => {
+      const result = convertBase({ value: '', fromBase: 10, toBase: 2 });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('EmptyInput');
+      }
+    });
+
+    it('should return error for invalid source base', () => {
+      const result = convertBase({ value: '101', fromBase: 3, toBase: 10 });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('InvalidBase');
+        expect(result.error.message).toContain('source base');
+      }
+    });
+
+    it('should return error for invalid target base', () => {
+      const result = convertBase({ value: '101', fromBase: 2, toBase: 5 });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('InvalidBase');
+        expect(result.error.message).toContain('target base');
+      }
+    });
+
+    it('should return error for invalid binary number', () => {
+      const result = convertBase({ value: '102', fromBase: 2, toBase: 10 });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('InvalidNumber');
+        expect(result.error.message).toContain('binary');
+      }
+    });
+
+    it('should return error for invalid octal number', () => {
+      const result = convertBase({ value: '89', fromBase: 8, toBase: 10 });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('InvalidNumber');
+        expect(result.error.message).toContain('octal');
+      }
+    });
+
+    it('should return error for invalid decimal number', () => {
+      const result = convertBase({ value: '12.5', fromBase: 10, toBase: 2 });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('InvalidNumber');
+        expect(result.error.message).toContain('decimal');
+      }
+    });
+
+    it('should return error for invalid hexadecimal number', () => {
+      const result = convertBase({ value: 'GHI', fromBase: 16, toBase: 10 });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('InvalidNumber');
+        expect(result.error.message).toContain('hexadecimal');
+      }
+    });
+
+    it('should return error for whitespace only value', () => {
+      const result = convertBase({ value: '   ', fromBase: 10, toBase: 2 });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('EmptyInput');
+      }
+    });
+  });
+
+  describe('Special values', () => {
+    it('should convert power of 2 values', () => {
+      const result = convertBase({ value: '256', fromBase: 10, toBase: 2 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('100000000');
+      }
+    });
+
+    it('should convert power of 16 values', () => {
+      const result = convertBase({ value: '10000', fromBase: 16, toBase: 10 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('65536');
+      }
+    });
+
+    it('should handle maximum 32-bit unsigned', () => {
+      const result = convertBase({ value: '4294967295', fromBase: 10, toBase: 2 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('11111111111111111111111111111111');
+      }
+    });
+  });
+});