@tomgiee/tsdp 1.0.0

package/dist/tests/unit/parser/primitive-parser.test.js

@@ -0,0 +1,261 @@
+"use strict";
+/**
+ * Tests for primitive-parser.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const scanner_1 = require("../../../src/parser/scanner");
+const primitive_parser_1 = require("../../../src/parser/primitive-parser");
+const errors_1 = require("../../../src/types/errors");
+describe('primitive-parser', () => {
+    describe('parseToken', () => {
+        it('should parse valid tokens', () => {
+            const scanner = new scanner_1.Scanner('RTP');
+            const token = (0, primitive_parser_1.parseToken)(scanner);
+            expect(token).toBe('RTP');
+        });
+        it('should parse tokens with various characters', () => {
+            const scanner = new scanner_1.Scanner('a1B2-test.name_v123');
+            const token = (0, primitive_parser_1.parseToken)(scanner);
+            expect(token).toBe('a1B2-test.name_v123');
+        });
+        it('should stop at whitespace', () => {
+            const scanner = new scanner_1.Scanner('token next');
+            const token = (0, primitive_parser_1.parseToken)(scanner);
+            expect(token).toBe('token');
+            expect(scanner.peek()).toBe(' ');
+        });
+        it('should throw if no token found', () => {
+            const scanner = new scanner_1.Scanner('   ');
+            expect(() => (0, primitive_parser_1.parseToken)(scanner)).toThrow(errors_1.ParseError);
+        });
+    });
+    describe('parseInteger', () => {
+        it('should parse positive integers', () => {
+            const scanner = new scanner_1.Scanner('12345');
+            const num = (0, primitive_parser_1.parseInteger)(scanner);
+            expect(num).toBe(12345);
+        });
+        it('should parse zero', () => {
+            const scanner = new scanner_1.Scanner('0');
+            const num = (0, primitive_parser_1.parseInteger)(scanner);
+            expect(num).toBe(0);
+        });
+        it('should stop at non-digit', () => {
+            const scanner = new scanner_1.Scanner('123abc');
+            const num = (0, primitive_parser_1.parseInteger)(scanner);
+            expect(num).toBe(123);
+            expect(scanner.peek()).toBe('a');
+        });
+        it('should throw if no digits found', () => {
+            const scanner = new scanner_1.Scanner('abc');
+            expect(() => (0, primitive_parser_1.parseInteger)(scanner)).toThrow(errors_1.ParseError);
+        });
+    });
+    describe('parseByte', () => {
+        it('should parse valid byte values', () => {
+            expect((0, primitive_parser_1.parseByte)(new scanner_1.Scanner('0'))).toBe(0);
+            expect((0, primitive_parser_1.parseByte)(new scanner_1.Scanner('128'))).toBe(128);
+            expect((0, primitive_parser_1.parseByte)(new scanner_1.Scanner('255'))).toBe(255);
+        });
+        it('should throw for values > 255', () => {
+            expect(() => (0, primitive_parser_1.parseByte)(new scanner_1.Scanner('256'))).toThrow(errors_1.ParseError);
+            expect(() => (0, primitive_parser_1.parseByte)(new scanner_1.Scanner('256'))).toThrow('out of range');
+        });
+        it('should throw for negative values', () => {
+            const scanner = new scanner_1.Scanner('-1');
+            expect(() => (0, primitive_parser_1.parseByte)(scanner)).toThrow(errors_1.ParseError);
+        });
+    });
+    describe('parseNonWSString', () => {
+        it('should parse non-whitespace string', () => {
+            const scanner = new scanner_1.Scanner('hello world');
+            const str = (0, primitive_parser_1.parseNonWSString)(scanner);
+            expect(str).toBe('hello');
+            expect(scanner.peek()).toBe(' ');
+        });
+        it('should stop at newline', () => {
+            const scanner = new scanner_1.Scanner('test\nnext');
+            const str = (0, primitive_parser_1.parseNonWSString)(scanner);
+            expect(str).toBe('test');
+            expect(scanner.peek()).toBe('\n');
+        });
+        it('should throw if starts with whitespace', () => {
+            const scanner = new scanner_1.Scanner(' test');
+            expect(() => (0, primitive_parser_1.parseNonWSString)(scanner)).toThrow(errors_1.ParseError);
+        });
+    });
+    describe('parseByteString', () => {
+        it('should parse byte-string', () => {
+            const scanner = new scanner_1.Scanner('test123!@#');
+            const str = (0, primitive_parser_1.parseByteString)(scanner);
+            expect(str).toBe('test123!@#');
+        });
+        it('should stop at newline', () => {
+            const scanner = new scanner_1.Scanner('test\nnext');
+            const str = (0, primitive_parser_1.parseByteString)(scanner);
+            expect(str).toBe('test');
+        });
+    });
+    describe('parseIP4Address', () => {
+        it('should parse valid IPv4 addresses', () => {
+            expect((0, primitive_parser_1.parseIP4Address)(new scanner_1.Scanner('192.168.1.1'))).toBe('192.168.1.1');
+            expect((0, primitive_parser_1.parseIP4Address)(new scanner_1.Scanner('0.0.0.0'))).toBe('0.0.0.0');
+            expect((0, primitive_parser_1.parseIP4Address)(new scanner_1.Scanner('255.255.255.255'))).toBe('255.255.255.255');
+        });
+        it('should stop at whitespace', () => {
+            const scanner = new scanner_1.Scanner('192.168.1.1 next');
+            const addr = (0, primitive_parser_1.parseIP4Address)(scanner);
+            expect(addr).toBe('192.168.1.1');
+            expect(scanner.peek()).toBe(' ');
+        });
+        it('should throw for invalid IPv4', () => {
+            expect(() => (0, primitive_parser_1.parseIP4Address)(new scanner_1.Scanner('256.1.1.1'))).toThrow(errors_1.ParseError);
+            expect(() => (0, primitive_parser_1.parseIP4Address)(new scanner_1.Scanner('192.168.1'))).toThrow(errors_1.ParseError);
+        });
+    });
+    describe('parseIP6Address', () => {
+        it('should parse valid IPv6 addresses', () => {
+            expect((0, primitive_parser_1.parseIP6Address)(new scanner_1.Scanner('2001:db8::1'))).toBe('2001:db8::1');
+            expect((0, primitive_parser_1.parseIP6Address)(new scanner_1.Scanner('::1'))).toBe('::1');
+            expect((0, primitive_parser_1.parseIP6Address)(new scanner_1.Scanner('fe80::1'))).toBe('fe80::1');
+        });
+        it('should parse IPv6 with mixed IPv4', () => {
+            const addr = (0, primitive_parser_1.parseIP6Address)(new scanner_1.Scanner('::ffff:192.0.2.1'));
+            expect(addr).toBe('::ffff:192.0.2.1');
+        });
+        it('should stop at whitespace', () => {
+            const scanner = new scanner_1.Scanner('2001:db8::1 next');
+            const addr = (0, primitive_parser_1.parseIP6Address)(scanner);
+            expect(addr).toBe('2001:db8::1');
+            expect(scanner.peek()).toBe(' ');
+        });
+        it('should throw for invalid IPv6', () => {
+            expect(() => (0, primitive_parser_1.parseIP6Address)(new scanner_1.Scanner('gggg::1'))).toThrow(errors_1.ParseError);
+            expect(() => (0, primitive_parser_1.parseIP6Address)(new scanner_1.Scanner('::1::2'))).toThrow(errors_1.ParseError);
+        });
+    });
+    describe('parseFQDN', () => {
+        it('should parse valid FQDNs', () => {
+            expect((0, primitive_parser_1.parseFQDN)(new scanner_1.Scanner('example.com'))).toBe('example.com');
+            expect((0, primitive_parser_1.parseFQDN)(new scanner_1.Scanner('sub.domain.example.org'))).toBe('sub.domain.example.org');
+            expect((0, primitive_parser_1.parseFQDN)(new scanner_1.Scanner('localhost'))).toBe('localhost');
+        });
+        it('should parse FQDN with hyphens', () => {
+            expect((0, primitive_parser_1.parseFQDN)(new scanner_1.Scanner('my-server.example.com'))).toBe('my-server.example.com');
+        });
+        it('should stop at whitespace', () => {
+            const scanner = new scanner_1.Scanner('example.com next');
+            const fqdn = (0, primitive_parser_1.parseFQDN)(scanner);
+            expect(fqdn).toBe('example.com');
+            expect(scanner.peek()).toBe(' ');
+        });
+        it('should throw for invalid FQDN', () => {
+            expect(() => (0, primitive_parser_1.parseFQDN)(new scanner_1.Scanner('-invalid.com'))).toThrow(errors_1.ParseError);
+            expect(() => (0, primitive_parser_1.parseFQDN)(new scanner_1.Scanner('invalid-.com'))).toThrow(errors_1.ParseError);
+        });
+    });
+    describe('parseNtpTime', () => {
+        it('should parse NTP timestamps', () => {
+            expect((0, primitive_parser_1.parseNtpTime)(new scanner_1.Scanner('0'))).toBe(0);
+            expect((0, primitive_parser_1.parseNtpTime)(new scanner_1.Scanner('3724394400'))).toBe(3724394400);
+        });
+        it('should stop at non-digit', () => {
+            const scanner = new scanner_1.Scanner('123 456');
+            const time = (0, primitive_parser_1.parseNtpTime)(scanner);
+            expect(time).toBe(123);
+            expect(scanner.peek()).toBe(' ');
+        });
+        it('should throw for negative values', () => {
+            const scanner = new scanner_1.Scanner('-1');
+            expect(() => (0, primitive_parser_1.parseNtpTime)(scanner)).toThrow(errors_1.ParseError);
+        });
+    });
+    describe('parseTypedTime', () => {
+        it('should parse time with days', () => {
+            const time = (0, primitive_parser_1.parseTypedTime)(new scanner_1.Scanner('7d'));
+            expect(time.value).toBe(7);
+            expect(time.unit).toBe('days');
+        });
+        it('should parse time with hours', () => {
+            const time = (0, primitive_parser_1.parseTypedTime)(new scanner_1.Scanner('3h'));
+            expect(time.value).toBe(3);
+            expect(time.unit).toBe('hours');
+        });
+        it('should parse time with minutes', () => {
+            const time = (0, primitive_parser_1.parseTypedTime)(new scanner_1.Scanner('120m'));
+            expect(time.value).toBe(120);
+            expect(time.unit).toBe('minutes');
+        });
+        it('should parse time with seconds (no suffix)', () => {
+            const time = (0, primitive_parser_1.parseTypedTime)(new scanner_1.Scanner('3600'));
+            expect(time.value).toBe(3600);
+            expect(time.unit).toBe('seconds');
+        });
+        it('should parse time with explicit seconds', () => {
+            const time = (0, primitive_parser_1.parseTypedTime)(new scanner_1.Scanner('30s'));
+            expect(time.value).toBe(30);
+            expect(time.unit).toBe('seconds');
+        });
+        it('should stop at whitespace', () => {
+            const scanner = new scanner_1.Scanner('7d 3h');
+            const time = (0, primitive_parser_1.parseTypedTime)(scanner);
+            expect(time.value).toBe(7);
+            expect(time.unit).toBe('days');
+            expect(scanner.peek()).toBe(' ');
+        });
+        it('should throw for invalid format', () => {
+            expect(() => (0, primitive_parser_1.parseTypedTime)(new scanner_1.Scanner('abc'))).toThrow(errors_1.ParseError);
+        });
+    });
+    describe('parseEmail', () => {
+        it('should parse email address', () => {
+            const scanner = new scanner_1.Scanner('user@example.com\n');
+            const email = (0, primitive_parser_1.parseEmail)(scanner);
+            expect(email).toBe('user@example.com');
+        });
+        it('should parse email with display name', () => {
+            const scanner = new scanner_1.Scanner('John Doe <john@example.com>\n');
+            const email = (0, primitive_parser_1.parseEmail)(scanner);
+            expect(email).toBe('John Doe <john@example.com>');
+        });
+        it('should stop at newline', () => {
+            const scanner = new scanner_1.Scanner('user@example.com\r\nnext line');
+            const email = (0, primitive_parser_1.parseEmail)(scanner);
+            expect(email).toBe('user@example.com');
+        });
+    });
+    describe('parsePhone', () => {
+        it('should parse phone number', () => {
+            const scanner = new scanner_1.Scanner('+1-555-1234\n');
+            const phone = (0, primitive_parser_1.parsePhone)(scanner);
+            expect(phone).toBe('+1-555-1234');
+        });
+        it('should parse phone with display name', () => {
+            const scanner = new scanner_1.Scanner('John Doe +1-555-1234\n');
+            const phone = (0, primitive_parser_1.parsePhone)(scanner);
+            expect(phone).toBe('John Doe +1-555-1234');
+        });
+        it('should stop at newline', () => {
+            const scanner = new scanner_1.Scanner('+1-555-1234\r\nnext');
+            const phone = (0, primitive_parser_1.parsePhone)(scanner);
+            expect(phone).toBe('+1-555-1234');
+        });
+    });
+    describe('parseURI', () => {
+        it('should parse HTTP URI', () => {
+            const scanner = new scanner_1.Scanner('http://example.com/path\n');
+            const uri = (0, primitive_parser_1.parseURI)(scanner);
+            expect(uri).toBe('http://example.com/path');
+        });
+        it('should parse HTTPS URI', () => {
+            const scanner = new scanner_1.Scanner('https://example.com:8080/path?query=value\n');
+            const uri = (0, primitive_parser_1.parseURI)(scanner);
+            expect(uri).toBe('https://example.com:8080/path?query=value');
+        });
+        it('should stop at newline', () => {
+            const scanner = new scanner_1.Scanner('http://example.com\r\nnext');
+            const uri = (0, primitive_parser_1.parseURI)(scanner);
+            expect(uri).toBe('http://example.com');
+        });
+    });
+});

package/dist/tests/unit/parser/scanner.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for scanner.ts
+ */
+export {};
+//# sourceMappingURL=scanner.test.d.ts.map

package/dist/tests/unit/parser/scanner.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanner.test.d.ts","sourceRoot":"","sources":["../../../../tests/unit/parser/scanner.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/tests/unit/parser/scanner.test.js

@@ -0,0 +1,241 @@
+"use strict";
+/**
+ * Tests for scanner.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const scanner_1 = require("../../../src/parser/scanner");
+const errors_1 = require("../../../src/types/errors");
+describe('Scanner', () => {
+    describe('basic operations', () => {
+        it('should peek at current character', () => {
+            const scanner = new scanner_1.Scanner('abc');
+            expect(scanner.peek()).toBe('a');
+            expect(scanner.peek()).toBe('a'); // Peek doesn't advance
+        });
+        it('should return null when peeking at EOF', () => {
+            const scanner = new scanner_1.Scanner('');
+            expect(scanner.peek()).toBeNull();
+        });
+        it('should advance through characters', () => {
+            const scanner = new scanner_1.Scanner('abc');
+            expect(scanner.advance()).toBe('a');
+            expect(scanner.advance()).toBe('b');
+            expect(scanner.advance()).toBe('c');
+            expect(scanner.advance()).toBeNull();
+        });
+        it('should peek ahead', () => {
+            const scanner = new scanner_1.Scanner('abcdef');
+            expect(scanner.peekAhead(0)).toBe('a');
+            expect(scanner.peekAhead(1)).toBe('b');
+            expect(scanner.peekAhead(5)).toBe('f');
+            expect(scanner.peekAhead(6)).toBeNull();
+        });
+    });
+    describe('position tracking', () => {
+        it('should track line and column', () => {
+            const scanner = new scanner_1.Scanner('abc\ndef');
+            const pos1 = scanner.getPosition();
+            expect(pos1.line).toBe(1);
+            expect(pos1.column).toBe(1);
+            expect(pos1.offset).toBe(0);
+            scanner.advance(); // 'a'
+            scanner.advance(); // 'b'
+            const pos2 = scanner.getPosition();
+            expect(pos2.line).toBe(1);
+            expect(pos2.column).toBe(3);
+            expect(pos2.offset).toBe(2);
+            scanner.advance(); // 'c'
+            scanner.advance(); // '\n'
+            const pos3 = scanner.getPosition();
+            expect(pos3.line).toBe(2);
+            expect(pos3.column).toBe(1);
+        });
+        it('should handle CRLF line endings', () => {
+            const scanner = new scanner_1.Scanner('a\r\nb');
+            scanner.advance(); // 'a'
+            scanner.advance(); // '\r\n'
+            const pos = scanner.getPosition();
+            expect(pos.line).toBe(2);
+            expect(pos.column).toBe(1);
+            expect(scanner.peek()).toBe('b');
+        });
+        it('should handle CR line endings', () => {
+            const scanner = new scanner_1.Scanner('a\rb');
+            scanner.advance(); // 'a'
+            scanner.advance(); // '\r'
+            const pos = scanner.getPosition();
+            expect(pos.line).toBe(2);
+            expect(pos.column).toBe(1);
+            expect(scanner.peek()).toBe('b');
+        });
+        it('should handle LF line endings', () => {
+            const scanner = new scanner_1.Scanner('a\nb');
+            scanner.advance(); // 'a'
+            scanner.advance(); // '\n'
+            const pos = scanner.getPosition();
+            expect(pos.line).toBe(2);
+            expect(pos.column).toBe(1);
+            expect(scanner.peek()).toBe('b');
+        });
+    });
+    describe('readUntil', () => {
+        it('should read until string delimiter', () => {
+            const scanner = new scanner_1.Scanner('hello world');
+            const result = scanner.readUntil(' ');
+            expect(result).toBe('hello');
+            expect(scanner.peek()).toBe(' ');
+        });
+        it('should read until regex delimiter', () => {
+            const scanner = new scanner_1.Scanner('abc123def');
+            const result = scanner.readUntil(/\d/);
+            expect(result).toBe('abc');
+            expect(scanner.peek()).toBe('1');
+        });
+        it('should read entire input if delimiter not found', () => {
+            const scanner = new scanner_1.Scanner('hello');
+            const result = scanner.readUntil('x');
+            expect(result).toBe('hello');
+            expect(scanner.isEOF()).toBe(true);
+        });
+    });
+    describe('readWhile', () => {
+        it('should read while predicate is true', () => {
+            const scanner = new scanner_1.Scanner('12345abc');
+            const result = scanner.readWhile(ch => ch >= '0' && ch <= '9');
+            expect(result).toBe('12345');
+            expect(scanner.peek()).toBe('a');
+        });
+        it('should return empty string if predicate immediately false', () => {
+            const scanner = new scanner_1.Scanner('abc');
+            const result = scanner.readWhile(ch => ch >= '0' && ch <= '9');
+            expect(result).toBe('');
+            expect(scanner.peek()).toBe('a');
+        });
+    });
+    describe('whitespace handling', () => {
+        it('should skip spaces and tabs', () => {
+            const scanner = new scanner_1.Scanner('  \t  abc');
+            scanner.skipWhitespace();
+            expect(scanner.peek()).toBe('a');
+        });
+        it('should not skip newlines', () => {
+            const scanner = new scanner_1.Scanner('  \n  abc');
+            scanner.skipWhitespace();
+            expect(scanner.peek()).toBe('\n');
+        });
+        it('should skip to next line', () => {
+            const scanner = new scanner_1.Scanner('hello world\nnext line');
+            scanner.skipToNextLine();
+            expect(scanner.peek()).toBe('n');
+            const pos = scanner.getPosition();
+            expect(pos.line).toBe(2);
+        });
+    });
+    describe('expect methods', () => {
+        it('should expect exact string', () => {
+            const scanner = new scanner_1.Scanner('v=0');
+            scanner.expect('v=');
+            expect(scanner.peek()).toBe('0');
+        });
+        it('should throw if string not matched', () => {
+            const scanner = new scanner_1.Scanner('o=test');
+            expect(() => scanner.expect('v=')).toThrow(errors_1.ParseError);
+        });
+        it('should throw if string extends past EOF', () => {
+            const scanner = new scanner_1.Scanner('v');
+            expect(() => scanner.expect('v=')).toThrow(errors_1.ParseError);
+        });
+        it('should expect character with predicate', () => {
+            const scanner = new scanner_1.Scanner('a123');
+            const ch = scanner.expectChar(c => c >= 'a' && c <= 'z', 'lowercase letter');
+            expect(ch).toBe('a');
+            expect(scanner.peek()).toBe('1');
+        });
+        it('should throw if character does not match predicate', () => {
+            const scanner = new scanner_1.Scanner('123');
+            expect(() => scanner.expectChar(c => c >= 'a' && c <= 'z', 'lowercase letter')).toThrow(errors_1.ParseError);
+        });
+        it('should expect space', () => {
+            const scanner = new scanner_1.Scanner(' abc');
+            scanner.expectSpace();
+            expect(scanner.peek()).toBe('a');
+        });
+        it('should throw if not space', () => {
+            const scanner = new scanner_1.Scanner('abc');
+            expect(() => scanner.expectSpace()).toThrow(errors_1.ParseError);
+        });
+        it('should expect end of line (CRLF)', () => {
+            const scanner = new scanner_1.Scanner('test\r\nnext');
+            scanner.advance();
+            scanner.advance();
+            scanner.advance();
+            scanner.advance();
+            scanner.expectEOL();
+            expect(scanner.peek()).toBe('n');
+        });
+        it('should expect end of line (LF)', () => {
+            const scanner = new scanner_1.Scanner('test\nnext');
+            scanner.advance();
+            scanner.advance();
+            scanner.advance();
+            scanner.advance();
+            scanner.expectEOL();
+            expect(scanner.peek()).toBe('n');
+        });
+        it('should accept EOF as EOL', () => {
+            const scanner = new scanner_1.Scanner('test');
+            scanner.advance();
+            scanner.advance();
+            scanner.advance();
+            scanner.advance();
+            scanner.expectEOL(); // Should not throw at EOF
+        });
+        it('should throw if not at EOL', () => {
+            const scanner = new scanner_1.Scanner('test');
+            expect(() => scanner.expectEOL()).toThrow(errors_1.ParseError);
+        });
+    });
+    describe('utility methods', () => {
+        it('should check if at EOF', () => {
+            const scanner = new scanner_1.Scanner('ab');
+            expect(scanner.isEOF()).toBe(false);
+            scanner.advance();
+            expect(scanner.isEOF()).toBe(false);
+            scanner.advance();
+            expect(scanner.isEOF()).toBe(true);
+        });
+        it('should get remaining input', () => {
+            const scanner = new scanner_1.Scanner('hello world');
+            scanner.advance();
+            scanner.advance();
+            expect(scanner.getRemainingInput()).toBe('llo world');
+        });
+        it('should get substring', () => {
+            const scanner = new scanner_1.Scanner('hello world');
+            scanner.advance();
+            scanner.advance();
+            scanner.advance();
+            const sub = scanner.getSubstring(0);
+            expect(sub).toBe('hel');
+        });
+    });
+    describe('error context', () => {
+        it('should provide context in error messages', () => {
+            const scanner = new scanner_1.Scanner('v=0\no=test 123 456 IN IP4 192.168.1.1\ns=Session');
+            scanner.advance();
+            scanner.advance();
+            scanner.advance();
+            scanner.advance(); // Move to 'o'
+            try {
+                scanner.expect('INVALID');
+                fail('Should have thrown');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(errors_1.ParseError);
+                const parseError = error;
+                expect(parseError.line).toBe(2);
+                expect(parseError.column).toBe(1);
+            }
+        });
+    });
+});

package/dist/tests/unit/parser/session-parser.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for session-parser.ts
+ */
+export {};
+//# sourceMappingURL=session-parser.test.d.ts.map

package/dist/tests/unit/parser/session-parser.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-parser.test.d.ts","sourceRoot":"","sources":["../../../../tests/unit/parser/session-parser.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}