calc-mcp-server 0.1.0

package/test/integration/ascii.test.ts

@@ -0,0 +1,450 @@
+import { describe, it, expect } from 'vitest';
+import { asciiToNumber, numberToAscii } from '../../src/mcp/tools/ascii.js';
+
+describe('asciiToNumber', () => {
+  describe('Single character conversions', () => {
+    it('should convert uppercase A to ASCII code', () => {
+      const result = asciiToNumber({ text: 'A' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('65');
+        expect(result.details?.expression).toContain('A');
+      }
+    });
+
+    it('should convert lowercase a to ASCII code', () => {
+      const result = asciiToNumber({ text: 'a' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('97');
+      }
+    });
+
+    it('should convert digit 0 to ASCII code', () => {
+      const result = asciiToNumber({ text: '0' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('48');
+      }
+    });
+
+    it('should convert space to ASCII code', () => {
+      const result = asciiToNumber({ text: ' ' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('32');
+      }
+    });
+
+    it('should convert newline to ASCII code', () => {
+      const result = asciiToNumber({ text: '\n' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('10');
+      }
+    });
+  });
+
+  describe('Multiple character conversions', () => {
+    it('should convert ABC to ASCII codes', () => {
+      const result = asciiToNumber({ text: 'ABC' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('65, 66, 67');
+      }
+    });
+
+    it('should convert Hello to ASCII codes', () => {
+      const result = asciiToNumber({ text: 'Hello' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('72, 101, 108, 108, 111');
+      }
+    });
+
+    it('should convert Hello World to ASCII codes', () => {
+      const result = asciiToNumber({ text: 'Hello World' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100');
+      }
+    });
+
+    it('should convert 123 to ASCII codes', () => {
+      const result = asciiToNumber({ text: '123' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('49, 50, 51');
+      }
+    });
+  });
+
+  describe('Special characters', () => {
+    it('should convert punctuation marks', () => {
+      const result = asciiToNumber({ text: '!' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('33');
+      }
+    });
+
+    it('should convert tab character', () => {
+      const result = asciiToNumber({ text: '\t' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('9');
+      }
+    });
+
+    it('should convert carriage return', () => {
+      const result = asciiToNumber({ text: '\r' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('13');
+      }
+    });
+
+    it('should convert at sign', () => {
+      const result = asciiToNumber({ text: '@' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('64');
+      }
+    });
+  });
+
+  describe('Steps in details', () => {
+    it('should include conversion steps', () => {
+      const result = asciiToNumber({ text: 'AB' });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.details?.steps).toBeDefined();
+        expect(result.details?.steps?.length).toBeGreaterThan(0);
+        expect(result.details?.steps?.[0]).toContain('AB');
+        expect(result.details?.steps?.[1]).toContain('2');
+      }
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should return error for empty string', () => {
+      const result = asciiToNumber({ text: '' });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('EmptyInput');
+      }
+    });
+  });
+});
+
+describe('numberToAscii', () => {
+  describe('Standard ASCII conversions', () => {
+    it('should convert 65 to A', () => {
+      const result = numberToAscii({ code: 65 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"A"');
+      }
+    });
+
+    it('should convert 97 to a', () => {
+      const result = numberToAscii({ code: 97 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"a"');
+      }
+    });
+
+    it('should convert 48 to 0', () => {
+      const result = numberToAscii({ code: 48 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"0"');
+      }
+    });
+
+    it('should convert 32 to space', () => {
+      const result = numberToAscii({ code: 32 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('" "');
+      }
+    });
+  });
+
+  describe('Extended ASCII/Unicode conversions', () => {
+    it('should convert 0 to null character', () => {
+      const result = numberToAscii({ code: 0 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"\x00"');
+      }
+    });
+
+    it('should convert 127 to DEL', () => {
+      const result = numberToAscii({ code: 127 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"\x7F"');
+      }
+    });
+
+    it('should convert 169 to copyright symbol', () => {
+      const result = numberToAscii({ code: 169 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"©"');
+      }
+    });
+  });
+
+  describe('Steps in details', () => {
+    it('should include conversion steps with hex and binary', () => {
+      const result = numberToAscii({ code: 65 });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.details?.steps).toBeDefined();
+        expect(result.details?.steps?.length).toBe(4);
+        expect(result.details?.steps?.[0]).toContain('65');
+        expect(result.details?.steps?.[1]).toContain('0x41');
+        expect(result.details?.steps?.[2]).toContain('Binary');
+        expect(result.details?.steps?.[3]).toContain('A');
+      }
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should return error for negative code', () => {
+      const result = numberToAscii({ code: -1 });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('InvalidNumber');
+        expect(result.error.message).toContain('Invalid Unicode');
+      }
+    });
+
+    it('should return error for code > 0xFFFF', () => {
+      const result = numberToAscii({ code: 65536 });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('InvalidNumber');
+        expect(result.error.message).toContain('surrogate pair');
+      }
+    });
+
+    it('should return error for code > 0x10FFFF', () => {
+      const result = numberToAscii({ code: 1114112 });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('InvalidNumber');
+        expect(result.error.message).toContain('Valid range');
+      }
+    });
+
+    it('should return error when both code and codes are provided', () => {
+      const result = numberToAscii({ code: 65, codes: [66, 67] });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('InvalidNumber');
+        expect(result.error.message).toContain('Only one');
+      }
+    });
+
+    it('should return error when neither code nor codes is provided', () => {
+      const result = numberToAscii({});
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('EmptyInput');
+        expect(result.error.message).toContain('Either code or codes');
+      }
+    });
+  });
+
+  describe('Batch conversions using codes parameter', () => {
+    it('should convert [72, 101, 108, 108, 111] to Hello', () => {
+      const result = numberToAscii({ codes: [72, 101, 108, 108, 111] });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"Hello"');
+      }
+    });
+
+    it('should convert [65, 66, 67] to ABC', () => {
+      const result = numberToAscii({ codes: [65, 66, 67] });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"ABC"');
+      }
+    });
+
+    it('should convert single code array', () => {
+      const result = numberToAscii({ codes: [88] });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"X"');
+      }
+    });
+
+    it('should convert codes with spaces', () => {
+      const result = numberToAscii({ codes: [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100] });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"Hello World"');
+      }
+    });
+
+    it('should convert letters and digits', () => {
+      const result = numberToAscii({ codes: [65, 49, 66, 50] });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"A1B2"');
+      }
+    });
+
+    it('should convert with punctuation', () => {
+      const result = numberToAscii({ codes: [72, 105, 33] });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"Hi!"');
+      }
+    });
+
+    it('should convert special characters', () => {
+      const result = numberToAscii({ codes: [32, 10, 9] });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('" \n\t"');
+      }
+    });
+
+    it('should include conversion steps in details', () => {
+      const result = numberToAscii({ codes: [72, 69, 76] });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.details?.steps).toBeDefined();
+        expect(result.details?.steps?.length).toBe(6);
+        expect(result.details?.steps?.[0]).toContain('[72, 69, 76]');
+        expect(result.details?.steps?.[5]).toContain('"HEL"');
+      }
+    });
+  });
+
+  describe('Batch error handling', () => {
+    it('should return error for empty array', () => {
+      const result = numberToAscii({ codes: [] });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('EmptyInput');
+      }
+    });
+
+    it('should return error for array with negative code', () => {
+      const result = numberToAscii({ codes: [65, -1, 67] });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('InvalidNumber');
+        expect(result.error.message).toContain('-1');
+      }
+    });
+
+    it('should return error for array with code > 0xFFFF', () => {
+      const result = numberToAscii({ codes: [65, 65536, 67] });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.type).toBe('InvalidNumber');
+        expect(result.error.message).toContain('65536');
+      }
+    });
+  });
+
+  describe('Extended Unicode batch conversions', () => {
+    it('should convert copyright symbol', () => {
+      const result = numberToAscii({ codes: [169, 174] });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"©®"');
+      }
+    });
+
+    it('should convert Euro sign', () => {
+      const result = numberToAscii({ codes: [8364] });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.result).toBe('"€"');
+      }
+    });
+  });
+});
+
+describe('Combined operations', () => {
+  it('should round-trip single character', () => {
+    const originalText = 'X';
+
+    const toNumberResult = asciiToNumber({ text: originalText });
+    expect(toNumberResult.success).toBe(true);
+
+    const code = parseInt(toNumberResult.result);
+    const toCharResult = numberToAscii({ code });
+
+    expect(toCharResult.success).toBe(true);
+    if (toCharResult.success) {
+      expect(toCharResult.result).toBe('"X"');
+    }
+  });
+
+  it('should round-trip multiple characters using codes parameter', () => {
+    const originalCodes = [72, 105, 33];
+
+    const toTextResult = numberToAscii({ codes: originalCodes });
+    expect(toTextResult.success).toBe(true);
+
+    const text = toTextResult.result?.replace(/"/g, '') ?? '';
+    const toCodesResult = asciiToNumber({ text });
+
+    expect(toCodesResult.success).toBe(true);
+    if (toCodesResult.success) {
+      expect(toCodesResult.result).toBe('72, 105, 33');
+    }
+  });
+});