@tomgiee/tsdp 1.0.0

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

@@ -0,0 +1,355 @@
+"use strict";
+/**
+ * Tests for field-parser.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const scanner_1 = require("../../../src/parser/scanner");
+const field_parser_1 = require("../../../src/parser/field-parser");
+const errors_1 = require("../../../src/types/errors");
+describe('field-parser', () => {
+    describe('parseVersionField', () => {
+        it('should parse version 0', () => {
+            const scanner = new scanner_1.Scanner('0');
+            const version = (0, field_parser_1.parseVersionField)(scanner);
+            expect(version).toBe(0);
+        });
+        it('should throw for non-zero version', () => {
+            expect(() => (0, field_parser_1.parseVersionField)(new scanner_1.Scanner('1'))).toThrow(errors_1.ParseError);
+            expect(() => (0, field_parser_1.parseVersionField)(new scanner_1.Scanner('1'))).toThrow('Unsupported SDP version');
+        });
+        it('should throw for invalid version', () => {
+            const scanner = new scanner_1.Scanner('abc');
+            expect(() => (0, field_parser_1.parseVersionField)(scanner)).toThrow(errors_1.ParseError);
+        });
+    });
+    describe('parseOriginField', () => {
+        it('should parse valid origin field', () => {
+            const scanner = new scanner_1.Scanner('jdoe 2890844526 2890842807 IN IP4 10.47.16.5');
+            const origin = (0, field_parser_1.parseOriginField)(scanner);
+            expect(origin.username).toBe('jdoe');
+            expect(origin.sessId).toBe('2890844526');
+            expect(origin.sessVersion).toBe('2890842807');
+            expect(origin.netType).toBe('IN');
+            expect(origin.addrType).toBe('IP4');
+            expect(origin.unicastAddress).toBe('10.47.16.5');
+        });
+        it('should parse origin with hyphen username', () => {
+            const scanner = new scanner_1.Scanner('- 123456 789012 IN IP4 192.168.1.1');
+            const origin = (0, field_parser_1.parseOriginField)(scanner);
+            expect(origin.username).toBe('-');
+            expect(origin.sessId).toBe('123456');
+            expect(origin.sessVersion).toBe('789012');
+        });
+        it('should parse origin with IPv6', () => {
+            const scanner = new scanner_1.Scanner('alice 123 456 IN IP6 2001:db8::1');
+            const origin = (0, field_parser_1.parseOriginField)(scanner);
+            expect(origin.username).toBe('alice');
+            expect(origin.netType).toBe('IN');
+            expect(origin.addrType).toBe('IP6');
+            expect(origin.unicastAddress).toBe('2001:db8::1');
+        });
+        it('should parse origin with FQDN', () => {
+            const scanner = new scanner_1.Scanner('bob 999 888 IN IP4 example.com');
+            const origin = (0, field_parser_1.parseOriginField)(scanner);
+            expect(origin.username).toBe('bob');
+            expect(origin.unicastAddress).toBe('example.com');
+        });
+        it('should throw for missing fields', () => {
+            expect(() => (0, field_parser_1.parseOriginField)(new scanner_1.Scanner('jdoe'))).toThrow(errors_1.ParseError);
+            expect(() => (0, field_parser_1.parseOriginField)(new scanner_1.Scanner('jdoe 123'))).toThrow(errors_1.ParseError);
+            expect(() => (0, field_parser_1.parseOriginField)(new scanner_1.Scanner('jdoe 123 456'))).toThrow(errors_1.ParseError);
+        });
+    });
+    describe('parseSessionNameField', () => {
+        it('should parse session name', () => {
+            const scanner = new scanner_1.Scanner('SDP Seminar');
+            const name = (0, field_parser_1.parseSessionNameField)(scanner);
+            expect(name).toBe('SDP Seminar');
+        });
+        it('should parse single space as session name', () => {
+            const scanner = new scanner_1.Scanner(' ');
+            const name = (0, field_parser_1.parseSessionNameField)(scanner);
+            expect(name).toBe(' ');
+        });
+        it('should parse session name with special characters', () => {
+            const scanner = new scanner_1.Scanner('My Conference Call #123');
+            const name = (0, field_parser_1.parseSessionNameField)(scanner);
+            expect(name).toBe('My Conference Call #123');
+        });
+        it('should throw for empty session name', () => {
+            const scanner = new scanner_1.Scanner('');
+            expect(() => (0, field_parser_1.parseSessionNameField)(scanner)).toThrow(errors_1.ParseError);
+            expect(() => (0, field_parser_1.parseSessionNameField)(scanner)).toThrow('cannot be empty');
+        });
+    });
+    describe('parseInformationField', () => {
+        it('should parse information text', () => {
+            const scanner = new scanner_1.Scanner('A Seminar on the session description protocol');
+            const info = (0, field_parser_1.parseInformationField)(scanner);
+            expect(info).toBe('A Seminar on the session description protocol');
+        });
+        it('should parse empty information', () => {
+            const scanner = new scanner_1.Scanner('');
+            const info = (0, field_parser_1.parseInformationField)(scanner);
+            expect(info).toBe('');
+        });
+        it('should stop at newline', () => {
+            const scanner = new scanner_1.Scanner('Session info\r\nnext line');
+            const info = (0, field_parser_1.parseInformationField)(scanner);
+            expect(info).toBe('Session info');
+        });
+    });
+    describe('parseUriField', () => {
+        it('should parse HTTP URI', () => {
+            const scanner = new scanner_1.Scanner('http://example.com/session');
+            const uri = (0, field_parser_1.parseUriField)(scanner);
+            expect(uri).toBe('http://example.com/session');
+        });
+        it('should parse HTTPS URI', () => {
+            const scanner = new scanner_1.Scanner('https://example.com:8080/path?query=value');
+            const uri = (0, field_parser_1.parseUriField)(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\n');
+            const uri = (0, field_parser_1.parseUriField)(scanner);
+            expect(uri).toBe('http://example.com');
+        });
+    });
+    describe('parseEmailField', () => {
+        it('should parse email address', () => {
+            const scanner = new scanner_1.Scanner('user@example.com');
+            const email = (0, field_parser_1.parseEmailField)(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>');
+            const email = (0, field_parser_1.parseEmailField)(scanner);
+            expect(email).toBe('John Doe <john@example.com>');
+        });
+        it('should stop at newline', () => {
+            const scanner = new scanner_1.Scanner('user@example.com\r\n');
+            const email = (0, field_parser_1.parseEmailField)(scanner);
+            expect(email).toBe('user@example.com');
+        });
+    });
+    describe('parsePhoneField', () => {
+        it('should parse phone number', () => {
+            const scanner = new scanner_1.Scanner('+1-555-1234');
+            const phone = (0, field_parser_1.parsePhoneField)(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');
+            const phone = (0, field_parser_1.parsePhoneField)(scanner);
+            expect(phone).toBe('John Doe +1-555-1234');
+        });
+        it('should stop at newline', () => {
+            const scanner = new scanner_1.Scanner('+1-555-1234\r\n');
+            const phone = (0, field_parser_1.parsePhoneField)(scanner);
+            expect(phone).toBe('+1-555-1234');
+        });
+    });
+    describe('parseConnectionField', () => {
+        it('should parse unicast IPv4 connection', () => {
+            const scanner = new scanner_1.Scanner('IN IP4 192.168.1.100');
+            const conn = (0, field_parser_1.parseConnectionField)(scanner);
+            expect(conn.netType).toBe('IN');
+            expect(conn.addrType).toBe('IP4');
+            expect(conn.connectionAddress).toBe('192.168.1.100');
+        });
+        it('should parse unicast IPv6 connection', () => {
+            const scanner = new scanner_1.Scanner('IN IP6 2001:db8::1');
+            const conn = (0, field_parser_1.parseConnectionField)(scanner);
+            expect(conn.netType).toBe('IN');
+            expect(conn.addrType).toBe('IP6');
+            expect(conn.connectionAddress).toBe('2001:db8::1');
+        });
+        it('should parse unicast FQDN connection', () => {
+            const scanner = new scanner_1.Scanner('IN IP4 example.com');
+            const conn = (0, field_parser_1.parseConnectionField)(scanner);
+            expect(conn.netType).toBe('IN');
+            expect(conn.addrType).toBe('IP4');
+            expect(conn.connectionAddress).toBe('example.com');
+        });
+        it('should parse IPv4 multicast with TTL', () => {
+            const scanner = new scanner_1.Scanner('IN IP4 224.2.36.42/127');
+            const conn = (0, field_parser_1.parseConnectionField)(scanner);
+            expect(conn.netType).toBe('IN');
+            expect(conn.addrType).toBe('IP4');
+            expect(conn.connectionAddress).toEqual({
+                kind: 'ip4-multicast',
+                address: '224.2.36.42',
+                ttl: 127,
+            });
+        });
+        it('should parse IPv4 multicast with TTL and numAddresses', () => {
+            const scanner = new scanner_1.Scanner('IN IP4 224.2.1.1/127/3');
+            const conn = (0, field_parser_1.parseConnectionField)(scanner);
+            expect(conn.connectionAddress).toEqual({
+                kind: 'ip4-multicast',
+                address: '224.2.1.1',
+                ttl: 127,
+                numAddresses: 3,
+            });
+        });
+        it('should parse IPv6 multicast with numAddresses', () => {
+            const scanner = new scanner_1.Scanner('IN IP6 ff15::101/3');
+            const conn = (0, field_parser_1.parseConnectionField)(scanner);
+            expect(conn.connectionAddress).toEqual({
+                kind: 'ip6-multicast',
+                address: 'ff15::101',
+                numAddresses: 3,
+            });
+        });
+        it('should parse FQDN multicast with TTL', () => {
+            const scanner = new scanner_1.Scanner('IN IP4 example.com/127');
+            const conn = (0, field_parser_1.parseConnectionField)(scanner);
+            expect(conn.connectionAddress).toEqual({
+                kind: 'fqdn-multicast',
+                address: 'example.com',
+                ttl: 127,
+            });
+        });
+        it('should parse FQDN multicast with TTL and numAddresses', () => {
+            const scanner = new scanner_1.Scanner('IN IP4 example.com/64/5');
+            const conn = (0, field_parser_1.parseConnectionField)(scanner);
+            expect(conn.connectionAddress).toEqual({
+                kind: 'fqdn-multicast',
+                address: 'example.com',
+                ttl: 64,
+                numAddresses: 5,
+            });
+        });
+        it('should throw for IPv6 multicast with TTL', () => {
+            expect(() => (0, field_parser_1.parseConnectionField)(new scanner_1.Scanner('IN IP6 ff15::101/127/3'))).toThrow(errors_1.ParseError);
+            expect(() => (0, field_parser_1.parseConnectionField)(new scanner_1.Scanner('IN IP6 ff15::101/127/3'))).toThrow('cannot have TTL');
+        });
+        it('should throw for missing address', () => {
+            const scanner = new scanner_1.Scanner('IN IP4 ');
+            expect(() => (0, field_parser_1.parseConnectionField)(scanner)).toThrow(errors_1.ParseError);
+        });
+        it('should throw for invalid IPv4', () => {
+            const scanner = new scanner_1.Scanner('IN IP4 -invalid-');
+            expect(() => (0, field_parser_1.parseConnectionField)(scanner)).toThrow(errors_1.ParseError);
+        });
+        it('should throw for unicast IPv4 address with TTL (RFC 8866 Section 5.7)', () => {
+            // 192.168.1.1 is a unicast address, not multicast
+            expect(() => (0, field_parser_1.parseConnectionField)(new scanner_1.Scanner('IN IP4 192.168.1.1/127'))).toThrow(errors_1.ParseError);
+            expect(() => (0, field_parser_1.parseConnectionField)(new scanner_1.Scanner('IN IP4 192.168.1.1/127'))).toThrow('must be a multicast address');
+        });
+        it('should throw for unicast IPv4 address with TTL and numAddresses', () => {
+            // 10.0.0.1 is a unicast address, not multicast
+            expect(() => (0, field_parser_1.parseConnectionField)(new scanner_1.Scanner('IN IP4 10.0.0.1/64/3'))).toThrow(errors_1.ParseError);
+            expect(() => (0, field_parser_1.parseConnectionField)(new scanner_1.Scanner('IN IP4 10.0.0.1/64/3'))).toThrow('must be a multicast address');
+        });
+        it('should throw for unicast IPv6 address with numAddresses (RFC 8866 Section 5.7)', () => {
+            // 2001:db8::1 is a unicast address, not multicast
+            expect(() => (0, field_parser_1.parseConnectionField)(new scanner_1.Scanner('IN IP6 2001:db8::1/3'))).toThrow(errors_1.ParseError);
+            expect(() => (0, field_parser_1.parseConnectionField)(new scanner_1.Scanner('IN IP6 2001:db8::1/3'))).toThrow('must be a multicast address');
+        });
+        it('should accept valid IPv4 multicast address with TTL', () => {
+            // 224.0.0.1 is a valid multicast address
+            const scanner = new scanner_1.Scanner('IN IP4 224.0.0.1/127');
+            const conn = (0, field_parser_1.parseConnectionField)(scanner);
+            expect(conn.connectionAddress).toEqual({
+                kind: 'ip4-multicast',
+                address: '224.0.0.1',
+                ttl: 127,
+            });
+        });
+        it('should accept valid IPv4 multicast address in range 224-239', () => {
+            // 239.255.255.255 is at the top of the multicast range
+            const scanner = new scanner_1.Scanner('IN IP4 239.255.255.255/64');
+            const conn = (0, field_parser_1.parseConnectionField)(scanner);
+            expect(conn.connectionAddress).toEqual({
+                kind: 'ip4-multicast',
+                address: '239.255.255.255',
+                ttl: 64,
+            });
+        });
+        it('should accept valid IPv6 multicast address with numAddresses', () => {
+            // FF02::1 is a valid IPv6 multicast address
+            const scanner = new scanner_1.Scanner('IN IP6 FF02::1/5');
+            const conn = (0, field_parser_1.parseConnectionField)(scanner);
+            expect(conn.connectionAddress).toEqual({
+                kind: 'ip6-multicast',
+                address: 'FF02::1',
+                numAddresses: 5,
+            });
+        });
+        it('should reject IPv4 address just below multicast range with TTL', () => {
+            // 223.255.255.255 is just below the multicast range (224-239)
+            expect(() => (0, field_parser_1.parseConnectionField)(new scanner_1.Scanner('IN IP4 223.255.255.255/127'))).toThrow(errors_1.ParseError);
+            expect(() => (0, field_parser_1.parseConnectionField)(new scanner_1.Scanner('IN IP4 223.255.255.255/127'))).toThrow('must be a multicast address');
+        });
+        it('should reject IPv4 address just above multicast range with TTL', () => {
+            // 240.0.0.0 is just above the multicast range (224-239)
+            expect(() => (0, field_parser_1.parseConnectionField)(new scanner_1.Scanner('IN IP4 240.0.0.0/127'))).toThrow(errors_1.ParseError);
+            expect(() => (0, field_parser_1.parseConnectionField)(new scanner_1.Scanner('IN IP4 240.0.0.0/127'))).toThrow('must be a multicast address');
+        });
+    });
+    describe('parseBandwidthField', () => {
+        it('should parse CT bandwidth', () => {
+            const scanner = new scanner_1.Scanner('CT:1000');
+            const bw = (0, field_parser_1.parseBandwidthField)(scanner);
+            expect(bw.type).toBe('CT');
+            expect(bw.value).toBe(1000);
+        });
+        it('should parse AS bandwidth', () => {
+            const scanner = new scanner_1.Scanner('AS:128');
+            const bw = (0, field_parser_1.parseBandwidthField)(scanner);
+            expect(bw.type).toBe('AS');
+            expect(bw.value).toBe(128);
+        });
+        it('should parse extension bandwidth type', () => {
+            const scanner = new scanner_1.Scanner('TIAS:64000');
+            const bw = (0, field_parser_1.parseBandwidthField)(scanner);
+            expect(bw.type).toBe('TIAS');
+            expect(bw.value).toBe(64000);
+        });
+        it('should parse zero bandwidth', () => {
+            const scanner = new scanner_1.Scanner('AS:0');
+            const bw = (0, field_parser_1.parseBandwidthField)(scanner);
+            expect(bw.value).toBe(0);
+        });
+        it('should throw for missing colon', () => {
+            expect(() => (0, field_parser_1.parseBandwidthField)(new scanner_1.Scanner('CT 1000'))).toThrow(errors_1.ParseError);
+            expect(() => (0, field_parser_1.parseBandwidthField)(new scanner_1.Scanner('CT 1000'))).toThrow('Expected \':\'');
+        });
+        it('should throw for missing value', () => {
+            const scanner = new scanner_1.Scanner('CT:');
+            expect(() => (0, field_parser_1.parseBandwidthField)(scanner)).toThrow(errors_1.ParseError);
+        });
+        it('should throw for negative bandwidth', () => {
+            expect(() => (0, field_parser_1.parseBandwidthField)(new scanner_1.Scanner('CT:-100'))).toThrow();
+        });
+    });
+    describe('parseKeyField', () => {
+        it('should parse clear key', () => {
+            const scanner = new scanner_1.Scanner('clear:mypassword123');
+            const key = (0, field_parser_1.parseKeyField)(scanner);
+            expect(key).toBe('clear:mypassword123');
+        });
+        it('should parse base64 key', () => {
+            const scanner = new scanner_1.Scanner('base64:dGVzdGtleQ==');
+            const key = (0, field_parser_1.parseKeyField)(scanner);
+            expect(key).toBe('base64:dGVzdGtleQ==');
+        });
+        it('should parse uri key', () => {
+            const scanner = new scanner_1.Scanner('uri:http://example.com/key');
+            const key = (0, field_parser_1.parseKeyField)(scanner);
+            expect(key).toBe('uri:http://example.com/key');
+        });
+        it('should parse prompt key', () => {
+            const scanner = new scanner_1.Scanner('prompt');
+            const key = (0, field_parser_1.parseKeyField)(scanner);
+            expect(key).toBe('prompt');
+        });
+        it('should stop at newline', () => {
+            const scanner = new scanner_1.Scanner('clear:key123\r\n');
+            const key = (0, field_parser_1.parseKeyField)(scanner);
+            expect(key).toBe('clear:key123');
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,241 @@
+"use strict";
+/**
+ * Tests for media-parser.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const scanner_1 = require("../../../src/parser/scanner");
+const media_parser_1 = require("../../../src/parser/media-parser");
+const errors_1 = require("../../../src/types/errors");
+describe('media-parser', () => {
+    describe('parseMediaField', () => {
+        it('should parse audio media with simple port', () => {
+            const scanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0 8 101');
+            const media = (0, media_parser_1.parseMediaField)(scanner);
+            expect(media.type).toBe('audio');
+            expect(media.port.kind).toBe('simple');
+            if (media.port.kind === 'simple') {
+                expect(media.port.value).toBe(49170);
+            }
+            expect(media.proto).toBe('RTP/AVP');
+            expect(media.formats).toEqual(['0', '8', '101']);
+        });
+        it('should parse video media', () => {
+            const scanner = new scanner_1.Scanner('video 51372 RTP/AVP 99');
+            const media = (0, media_parser_1.parseMediaField)(scanner);
+            expect(media.type).toBe('video');
+            expect(media.port.kind).toBe('simple');
+            if (media.port.kind === 'simple') {
+                expect(media.port.value).toBe(51372);
+            }
+            expect(media.proto).toBe('RTP/AVP');
+            expect(media.formats).toEqual(['99']);
+        });
+        it('should parse media with port range', () => {
+            const scanner = new scanner_1.Scanner('audio 49170/2 RTP/AVP 0');
+            const media = (0, media_parser_1.parseMediaField)(scanner);
+            expect(media.type).toBe('audio');
+            expect(media.port.kind).toBe('range');
+            if (media.port.kind === 'range') {
+                expect(media.port.base).toBe(49170);
+                expect(media.port.count).toBe(2);
+            }
+            expect(media.proto).toBe('RTP/AVP');
+            expect(media.formats).toEqual(['0']);
+        });
+        it('should parse text media', () => {
+            const scanner = new scanner_1.Scanner('text 49174 RTP/AVP 96');
+            const media = (0, media_parser_1.parseMediaField)(scanner);
+            expect(media.type).toBe('text');
+        });
+        it('should parse application media', () => {
+            const scanner = new scanner_1.Scanner('application 49175 udp wb');
+            const media = (0, media_parser_1.parseMediaField)(scanner);
+            expect(media.type).toBe('application');
+            expect(media.proto).toBe('udp');
+            expect(media.formats).toEqual(['wb']);
+        });
+        it('should parse message media', () => {
+            const scanner = new scanner_1.Scanner('message 49176 RTP/AVP 97');
+            const media = (0, media_parser_1.parseMediaField)(scanner);
+            expect(media.type).toBe('message');
+        });
+        it('should parse image media', () => {
+            const scanner = new scanner_1.Scanner('image 49177 udp t38');
+            const media = (0, media_parser_1.parseMediaField)(scanner);
+            expect(media.type).toBe('image');
+            expect(media.formats).toEqual(['t38']);
+        });
+        it('should parse media with port 0 (disabled)', () => {
+            const scanner = new scanner_1.Scanner('audio 0 RTP/AVP 0');
+            const media = (0, media_parser_1.parseMediaField)(scanner);
+            expect(media.port.kind).toBe('simple');
+            if (media.port.kind === 'simple') {
+                expect(media.port.value).toBe(0);
+            }
+        });
+        it('should parse media with multiple formats', () => {
+            const scanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0 8 3 18 101');
+            const media = (0, media_parser_1.parseMediaField)(scanner);
+            expect(media.formats).toHaveLength(5);
+            expect(media.formats).toEqual(['0', '8', '3', '18', '101']);
+        });
+        it('should parse media with RTP/SAVP protocol', () => {
+            const scanner = new scanner_1.Scanner('audio 49170 RTP/SAVP 0');
+            const media = (0, media_parser_1.parseMediaField)(scanner);
+            expect(media.proto).toBe('RTP/SAVP');
+        });
+        it('should parse media with RTP/SAVPF protocol', () => {
+            const scanner = new scanner_1.Scanner('audio 49170 RTP/SAVPF 111');
+            const media = (0, media_parser_1.parseMediaField)(scanner);
+            expect(media.proto).toBe('RTP/SAVPF');
+        });
+        it('should throw for invalid port number', () => {
+            expect(() => (0, media_parser_1.parseMediaField)(new scanner_1.Scanner('audio abc RTP/AVP 0'))).toThrow(errors_1.ParseError);
+            expect(() => (0, media_parser_1.parseMediaField)(new scanner_1.Scanner('audio abc RTP/AVP 0'))).toThrow('Invalid port number');
+        });
+        it('should throw for invalid port range', () => {
+            expect(() => (0, media_parser_1.parseMediaField)(new scanner_1.Scanner('audio 49170/abc RTP/AVP 0'))).toThrow(errors_1.ParseError);
+            expect(() => (0, media_parser_1.parseMediaField)(new scanner_1.Scanner('audio 49170/abc RTP/AVP 0'))).toThrow('Invalid port range');
+        });
+        it('should throw for missing formats', () => {
+            expect(() => (0, media_parser_1.parseMediaField)(new scanner_1.Scanner('audio 49170 RTP/AVP'))).toThrow(errors_1.ParseError);
+            expect(() => (0, media_parser_1.parseMediaField)(new scanner_1.Scanner('audio 49170 RTP/AVP'))).toThrow('at least one media format');
+        });
+        it('should throw for port out of range', () => {
+            expect(() => (0, media_parser_1.parseMediaField)(new scanner_1.Scanner('audio 70000 RTP/AVP 0'))).toThrow();
+        });
+        it('should throw for negative port', () => {
+            expect(() => (0, media_parser_1.parseMediaField)(new scanner_1.Scanner('audio -1 RTP/AVP 0'))).toThrow();
+        });
+        it('should throw for invalid port range format', () => {
+            expect(() => (0, media_parser_1.parseMediaField)(new scanner_1.Scanner('audio 49170/2/3 RTP/AVP 0'))).toThrow(errors_1.ParseError);
+            expect(() => (0, media_parser_1.parseMediaField)(new scanner_1.Scanner('audio 49170/2/3 RTP/AVP 0'))).toThrow('Invalid port range format');
+        });
+    });
+    describe('parseMediaDescription', () => {
+        it('should parse minimal media description (m= only)', () => {
+            const mediaScanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0');
+            const md = (0, media_parser_1.parseMediaDescription)(mediaScanner, []);
+            expect(md.media.type).toBe('audio');
+            expect(md.information).toBeUndefined();
+            expect(md.connections).toHaveLength(0);
+            expect(md.bandwidths).toHaveLength(0);
+            expect(md.key).toBeUndefined();
+            expect(md.attributes).toHaveLength(0);
+        });
+        it('should parse media description with information', () => {
+            const mediaScanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0');
+            const md = (0, media_parser_1.parseMediaDescription)(mediaScanner, [
+                { type: 'i', value: 'Audio Stream' },
+            ]);
+            expect(md.information).toBe('Audio Stream');
+        });
+        it('should parse media description with connection', () => {
+            const mediaScanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0');
+            const md = (0, media_parser_1.parseMediaDescription)(mediaScanner, [
+                { type: 'c', value: 'IN IP4 192.168.1.100' },
+            ]);
+            expect(md.connections).toHaveLength(1);
+            expect(md.connections[0].netType).toBe('IN');
+            expect(md.connections[0].addrType).toBe('IP4');
+        });
+        it('should parse media description with multiple connections', () => {
+            const mediaScanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0');
+            const md = (0, media_parser_1.parseMediaDescription)(mediaScanner, [
+                { type: 'c', value: 'IN IP4 192.168.1.100' },
+                { type: 'c', value: 'IN IP4 192.168.1.101' },
+            ]);
+            expect(md.connections).toHaveLength(2);
+        });
+        it('should parse media description with bandwidth', () => {
+            const mediaScanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0');
+            const md = (0, media_parser_1.parseMediaDescription)(mediaScanner, [
+                { type: 'b', value: 'AS:64' },
+            ]);
+            expect(md.bandwidths).toHaveLength(1);
+            expect(md.bandwidths[0].type).toBe('AS');
+            expect(md.bandwidths[0].value).toBe(64);
+        });
+        it('should parse media description with multiple bandwidths', () => {
+            const mediaScanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0');
+            const md = (0, media_parser_1.parseMediaDescription)(mediaScanner, [
+                { type: 'b', value: 'AS:64' },
+                { type: 'b', value: 'CT:128' },
+            ]);
+            expect(md.bandwidths).toHaveLength(2);
+        });
+        it('should parse media description with key', () => {
+            const mediaScanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0');
+            const md = (0, media_parser_1.parseMediaDescription)(mediaScanner, [
+                { type: 'k', value: 'clear:mykey123' },
+            ]);
+            expect(md.key).toBe('clear:mykey123');
+        });
+        it('should parse media description with attributes', () => {
+            const mediaScanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0 8');
+            const md = (0, media_parser_1.parseMediaDescription)(mediaScanner, [
+                { type: 'a', value: 'rtpmap:0 PCMU/8000' },
+                { type: 'a', value: 'rtpmap:8 PCMA/8000' },
+                { type: 'a', value: 'ptime:20' },
+                { type: 'a', value: 'sendrecv' },
+            ]);
+            expect(md.attributes).toHaveLength(4);
+        });
+        it('should parse complete media description with all fields', () => {
+            const mediaScanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0');
+            const md = (0, media_parser_1.parseMediaDescription)(mediaScanner, [
+                { type: 'i', value: 'Voice' },
+                { type: 'c', value: 'IN IP4 192.168.1.100' },
+                { type: 'b', value: 'AS:64' },
+                { type: 'k', value: 'clear:key' },
+                { type: 'a', value: 'rtpmap:0 PCMU/8000' },
+                { type: 'a', value: 'sendrecv' },
+            ]);
+            expect(md.information).toBe('Voice');
+            expect(md.connections).toHaveLength(1);
+            expect(md.bandwidths).toHaveLength(1);
+            expect(md.key).toBe('clear:key');
+            expect(md.attributes).toHaveLength(2);
+        });
+        it('should parse media description with correct field ordering', () => {
+            const mediaScanner = new scanner_1.Scanner('video 51372 RTP/AVP 99');
+            const md = (0, media_parser_1.parseMediaDescription)(mediaScanner, [
+                { type: 'i', value: 'Video Stream' },
+                { type: 'c', value: 'IN IP4 192.168.1.100' },
+                { type: 'b', value: 'AS:384' },
+                { type: 'k', value: 'prompt' },
+                { type: 'a', value: 'rtpmap:99 H264/90000' },
+                { type: 'a', value: 'fmtp:99 profile-level-id=42e01f' },
+            ]);
+            expect(md.media.type).toBe('video');
+            expect(md.information).toBe('Video Stream');
+        });
+        it('should throw for duplicate information field', () => {
+            const mediaScanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0');
+            expect(() => (0, media_parser_1.parseMediaDescription)(mediaScanner, [
+                { type: 'i', value: 'First' },
+                { type: 'i', value: 'Second' },
+            ])).toThrow(errors_1.ParseError);
+            expect(() => (0, media_parser_1.parseMediaDescription)(new scanner_1.Scanner('audio 49170 RTP/AVP 0'), [
+                { type: 'i', value: 'First' },
+                { type: 'i', value: 'Second' },
+            ])).toThrow('Duplicate information field');
+        });
+        it('should throw for duplicate key field', () => {
+            const mediaScanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0');
+            expect(() => (0, media_parser_1.parseMediaDescription)(mediaScanner, [
+                { type: 'k', value: 'clear:key1' },
+                { type: 'k', value: 'clear:key2' },
+            ])).toThrow(errors_1.ParseError);
+            expect(() => (0, media_parser_1.parseMediaDescription)(new scanner_1.Scanner('audio 49170 RTP/AVP 0'), [
+                { type: 'k', value: 'clear:key1' },
+                { type: 'k', value: 'clear:key2' },
+            ])).toThrow('Duplicate key field');
+        });
+        it('should throw for unexpected field type', () => {
+            const mediaScanner = new scanner_1.Scanner('audio 49170 RTP/AVP 0');
+            expect(() => (0, media_parser_1.parseMediaDescription)(mediaScanner, [{ type: 'v', value: '0' }])).toThrow(errors_1.ParseError);
+            expect(() => (0, media_parser_1.parseMediaDescription)(new scanner_1.Scanner('audio 49170 RTP/AVP 0'), [{ type: 'v', value: '0' }])).toThrow('Unexpected field type');
+        });
+    });
+});

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

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

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

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