@tomgiee/tsdp 1.0.0

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

@@ -0,0 +1,319 @@
+"use strict";
+/**
+ * Tests for attribute-parser.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const scanner_1 = require("../../../src/parser/scanner");
+const attribute_parser_1 = require("../../../src/parser/attribute-parser");
+const errors_1 = require("../../../src/types/errors");
+describe('attribute-parser', () => {
+    describe('parseAttributeField', () => {
+        describe('property attributes', () => {
+            it('should parse recvonly attribute', () => {
+                const scanner = new scanner_1.Scanner('recvonly');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('property');
+                expect(attr.name).toBe('recvonly');
+            });
+            it('should parse sendrecv attribute', () => {
+                const scanner = new scanner_1.Scanner('sendrecv');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('property');
+                expect(attr.name).toBe('sendrecv');
+            });
+            it('should parse sendonly attribute', () => {
+                const scanner = new scanner_1.Scanner('sendonly');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('property');
+                expect(attr.name).toBe('sendonly');
+            });
+            it('should parse inactive attribute', () => {
+                const scanner = new scanner_1.Scanner('inactive');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('property');
+                expect(attr.name).toBe('inactive');
+            });
+            it('should parse custom property attribute', () => {
+                const scanner = new scanner_1.Scanner('myattr');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('property');
+                expect(attr.name).toBe('myattr');
+            });
+        });
+        describe('value attributes', () => {
+            it('should parse rtpmap attribute', () => {
+                const scanner = new scanner_1.Scanner('rtpmap:0 PCMU/8000');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('rtpmap');
+                expect(attr.value).toBe('0 PCMU/8000');
+            });
+            it('should parse fmtp attribute', () => {
+                const scanner = new scanner_1.Scanner('fmtp:96 profile-level-id=42e01f');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('fmtp');
+                expect(attr.value).toBe('96 profile-level-id=42e01f');
+            });
+            it('should parse ptime attribute', () => {
+                const scanner = new scanner_1.Scanner('ptime:20');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('ptime');
+                expect(attr.value).toBe('20');
+            });
+            it('should parse maxptime attribute', () => {
+                const scanner = new scanner_1.Scanner('maxptime:150');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('maxptime');
+                expect(attr.value).toBe('150');
+            });
+            it('should parse cat attribute', () => {
+                const scanner = new scanner_1.Scanner('cat:conference');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('cat');
+                expect(attr.value).toBe('conference');
+            });
+            it('should parse keywds attribute', () => {
+                const scanner = new scanner_1.Scanner('keywds:audio,video,meeting');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('keywds');
+                expect(attr.value).toBe('audio,video,meeting');
+            });
+            it('should parse tool attribute', () => {
+                const scanner = new scanner_1.Scanner('tool:my-sdp-tool v1.0');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('tool');
+                expect(attr.value).toBe('my-sdp-tool v1.0');
+            });
+            it('should parse orient attribute', () => {
+                const scanner = new scanner_1.Scanner('orient:landscape');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('orient');
+                expect(attr.value).toBe('landscape');
+            });
+            it('should parse type attribute', () => {
+                const scanner = new scanner_1.Scanner('type:broadcast');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('type');
+                expect(attr.value).toBe('broadcast');
+            });
+            it('should parse charset attribute', () => {
+                const scanner = new scanner_1.Scanner('charset:UTF-8');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('charset');
+                expect(attr.value).toBe('UTF-8');
+            });
+            it('should parse sdplang attribute', () => {
+                const scanner = new scanner_1.Scanner('sdplang:en-US');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('sdplang');
+                expect(attr.value).toBe('en-US');
+            });
+            it('should parse lang attribute', () => {
+                const scanner = new scanner_1.Scanner('lang:fr');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('lang');
+                expect(attr.value).toBe('fr');
+            });
+            it('should parse framerate attribute', () => {
+                const scanner = new scanner_1.Scanner('framerate:29.97');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('framerate');
+                expect(attr.value).toBe('29.97');
+            });
+            it('should parse quality attribute', () => {
+                const scanner = new scanner_1.Scanner('quality:8');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('quality');
+                expect(attr.value).toBe('8');
+            });
+            it('should parse custom value attribute', () => {
+                const scanner = new scanner_1.Scanner('customattr:customvalue');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('customattr');
+                expect(attr.value).toBe('customvalue');
+            });
+            it('should parse value with colons', () => {
+                const scanner = new scanner_1.Scanner('candidate:1 1 UDP 2130706431 192.168.1.1 8998 typ host');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.kind).toBe('value');
+                expect(attr.name).toBe('candidate');
+                expect(attr.value).toBe('1 1 UDP 2130706431 192.168.1.1 8998 typ host');
+            });
+            it('should stop at newline', () => {
+                const scanner = new scanner_1.Scanner('rtpmap:0 PCMU/8000\r\n');
+                const attr = (0, attribute_parser_1.parseAttributeField)(scanner);
+                expect(attr.value).toBe('0 PCMU/8000');
+            });
+        });
+    });
+    describe('parseRtpmapValue', () => {
+        it('should parse basic rtpmap', () => {
+            const rtpmap = (0, attribute_parser_1.parseRtpmapValue)('0 PCMU/8000');
+            expect(rtpmap.payloadType).toBe(0);
+            expect(rtpmap.encodingName).toBe('PCMU');
+            expect(rtpmap.clockRate).toBe(8000);
+            expect(rtpmap.encodingParams).toBeUndefined();
+        });
+        it('should parse rtpmap with encoding params', () => {
+            const rtpmap = (0, attribute_parser_1.parseRtpmapValue)('97 L16/8000/2');
+            expect(rtpmap.payloadType).toBe(97);
+            expect(rtpmap.encodingName).toBe('L16');
+            expect(rtpmap.clockRate).toBe(8000);
+            expect(rtpmap.encodingParams).toBe(2);
+        });
+        it('should parse video rtpmap', () => {
+            const rtpmap = (0, attribute_parser_1.parseRtpmapValue)('96 H264/90000');
+            expect(rtpmap.payloadType).toBe(96);
+            expect(rtpmap.encodingName).toBe('H264');
+            expect(rtpmap.clockRate).toBe(90000);
+        });
+        it('should parse PCMA rtpmap', () => {
+            const rtpmap = (0, attribute_parser_1.parseRtpmapValue)('8 PCMA/8000');
+            expect(rtpmap.payloadType).toBe(8);
+            expect(rtpmap.encodingName).toBe('PCMA');
+            expect(rtpmap.clockRate).toBe(8000);
+        });
+        it('should parse telephone-event rtpmap', () => {
+            const rtpmap = (0, attribute_parser_1.parseRtpmapValue)('101 telephone-event/8000');
+            expect(rtpmap.payloadType).toBe(101);
+            expect(rtpmap.encodingName).toBe('telephone-event');
+            expect(rtpmap.clockRate).toBe(8000);
+        });
+        it('should throw for invalid payload type', () => {
+            expect(() => (0, attribute_parser_1.parseRtpmapValue)('abc PCMU/8000')).toThrow(errors_1.ParseError);
+            expect(() => (0, attribute_parser_1.parseRtpmapValue)('abc PCMU/8000')).toThrow('Invalid payload type');
+        });
+        it('should throw for payload type out of range', () => {
+            expect(() => (0, attribute_parser_1.parseRtpmapValue)('128 PCMU/8000')).toThrow(errors_1.ParseError);
+            expect(() => (0, attribute_parser_1.parseRtpmapValue)('-1 PCMU/8000')).toThrow(errors_1.ParseError);
+        });
+        it('should throw for missing encoding spec', () => {
+            expect(() => (0, attribute_parser_1.parseRtpmapValue)('96')).toThrow(errors_1.ParseError);
+            expect(() => (0, attribute_parser_1.parseRtpmapValue)('96')).toThrow('Invalid rtpmap format');
+        });
+        it('should throw for invalid encoding spec', () => {
+            expect(() => (0, attribute_parser_1.parseRtpmapValue)('96 H264')).toThrow(errors_1.ParseError);
+            expect(() => (0, attribute_parser_1.parseRtpmapValue)('96 H264')).toThrow('Invalid encoding spec');
+        });
+        it('should throw for invalid clock rate', () => {
+            expect(() => (0, attribute_parser_1.parseRtpmapValue)('96 H264/abc')).toThrow(errors_1.ParseError);
+            expect(() => (0, attribute_parser_1.parseRtpmapValue)('96 H264/0')).toThrow('Invalid clock rate');
+        });
+        it('should throw for invalid encoding params', () => {
+            expect(() => (0, attribute_parser_1.parseRtpmapValue)('97 L16/8000/abc')).toThrow(errors_1.ParseError);
+            expect(() => (0, attribute_parser_1.parseRtpmapValue)('97 L16/8000/0')).toThrow('Invalid encoding parameters');
+        });
+    });
+    describe('parseFmtpValue', () => {
+        it('should parse fmtp with profile', () => {
+            const fmtp = (0, attribute_parser_1.parseFmtpValue)('96 profile-level-id=42e01f');
+            expect(fmtp.format).toBe('96');
+            expect(fmtp.parameters).toBe('profile-level-id=42e01f');
+        });
+        it('should parse fmtp with multiple parameters', () => {
+            const fmtp = (0, attribute_parser_1.parseFmtpValue)('96 profile-level-id=42e01f;packetization-mode=1');
+            expect(fmtp.format).toBe('96');
+            expect(fmtp.parameters).toBe('profile-level-id=42e01f;packetization-mode=1');
+        });
+        it('should parse fmtp with apt', () => {
+            const fmtp = (0, attribute_parser_1.parseFmtpValue)('97 apt=96');
+            expect(fmtp.format).toBe('97');
+            expect(fmtp.parameters).toBe('apt=96');
+        });
+        it('should parse telephone-event fmtp', () => {
+            const fmtp = (0, attribute_parser_1.parseFmtpValue)('101 0-15');
+            expect(fmtp.format).toBe('101');
+            expect(fmtp.parameters).toBe('0-15');
+        });
+        it('should throw for missing parameters', () => {
+            expect(() => (0, attribute_parser_1.parseFmtpValue)('96')).toThrow(errors_1.ParseError);
+            expect(() => (0, attribute_parser_1.parseFmtpValue)('96')).toThrow('Invalid fmtp format');
+        });
+        it('should throw for empty parameters', () => {
+            expect(() => (0, attribute_parser_1.parseFmtpValue)('96 ')).toThrow(errors_1.ParseError);
+            expect(() => (0, attribute_parser_1.parseFmtpValue)('96 ')).toThrow('parameters cannot be empty');
+        });
+    });
+    describe('parsePtimeValue', () => {
+        it('should parse valid integer ptime', () => {
+            expect((0, attribute_parser_1.parsePtimeValue)('20')).toBe(20);
+            expect((0, attribute_parser_1.parsePtimeValue)('30')).toBe(30);
+            expect((0, attribute_parser_1.parsePtimeValue)('60')).toBe(60);
+        });
+        it('should parse valid decimal ptime (RFC 8866 non-zero-int-or-real)', () => {
+            expect((0, attribute_parser_1.parsePtimeValue)('20.5')).toBeCloseTo(20.5, 2);
+            expect((0, attribute_parser_1.parsePtimeValue)('30.0')).toBeCloseTo(30.0, 2);
+            expect((0, attribute_parser_1.parsePtimeValue)('0.5')).toBeCloseTo(0.5, 2);
+            expect((0, attribute_parser_1.parsePtimeValue)('100.125')).toBeCloseTo(100.125, 3);
+        });
+        it('should throw for invalid ptime', () => {
+            expect(() => (0, attribute_parser_1.parsePtimeValue)('abc')).toThrow(errors_1.ParseError);
+            expect(() => (0, attribute_parser_1.parsePtimeValue)('0')).toThrow('must be positive');
+            expect(() => (0, attribute_parser_1.parsePtimeValue)('-10')).toThrow('must be positive');
+            expect(() => (0, attribute_parser_1.parsePtimeValue)('-0.5')).toThrow('must be positive');
+        });
+    });
+    describe('parseMaxptimeValue', () => {
+        it('should parse valid integer maxptime', () => {
+            expect((0, attribute_parser_1.parseMaxptimeValue)('150')).toBe(150);
+            expect((0, attribute_parser_1.parseMaxptimeValue)('200')).toBe(200);
+        });
+        it('should parse valid decimal maxptime (RFC 8866 non-zero-int-or-real)', () => {
+            expect((0, attribute_parser_1.parseMaxptimeValue)('150.5')).toBeCloseTo(150.5, 2);
+            expect((0, attribute_parser_1.parseMaxptimeValue)('200.0')).toBeCloseTo(200.0, 2);
+            expect((0, attribute_parser_1.parseMaxptimeValue)('0.5')).toBeCloseTo(0.5, 2);
+            expect((0, attribute_parser_1.parseMaxptimeValue)('100.125')).toBeCloseTo(100.125, 3);
+        });
+        it('should throw for invalid maxptime', () => {
+            expect(() => (0, attribute_parser_1.parseMaxptimeValue)('abc')).toThrow(errors_1.ParseError);
+            expect(() => (0, attribute_parser_1.parseMaxptimeValue)('0')).toThrow('must be positive');
+            expect(() => (0, attribute_parser_1.parseMaxptimeValue)('-10')).toThrow('must be positive');
+            expect(() => (0, attribute_parser_1.parseMaxptimeValue)('-0.5')).toThrow('must be positive');
+        });
+    });
+    describe('parseFramerateValue', () => {
+        it('should parse integer framerate', () => {
+            expect((0, attribute_parser_1.parseFramerateValue)('30')).toBe(30);
+            expect((0, attribute_parser_1.parseFramerateValue)('60')).toBe(60);
+        });
+        it('should parse decimal framerate', () => {
+            expect((0, attribute_parser_1.parseFramerateValue)('29.97')).toBeCloseTo(29.97, 2);
+            expect((0, attribute_parser_1.parseFramerateValue)('23.976')).toBeCloseTo(23.976, 3);
+        });
+        it('should throw for invalid framerate', () => {
+            expect(() => (0, attribute_parser_1.parseFramerateValue)('abc')).toThrow(errors_1.ParseError);
+            expect(() => (0, attribute_parser_1.parseFramerateValue)('0')).toThrow('must be positive');
+            expect(() => (0, attribute_parser_1.parseFramerateValue)('-30')).toThrow('must be positive');
+        });
+    });
+    describe('parseQualityValue', () => {
+        it('should parse valid quality values', () => {
+            expect((0, attribute_parser_1.parseQualityValue)('0')).toBe(0);
+            expect((0, attribute_parser_1.parseQualityValue)('5')).toBe(5);
+            expect((0, attribute_parser_1.parseQualityValue)('10')).toBe(10);
+        });
+        it('should throw for quality out of range', () => {
+            expect(() => (0, attribute_parser_1.parseQualityValue)('-1')).toThrow(errors_1.ParseError);
+            expect(() => (0, attribute_parser_1.parseQualityValue)('-1')).toThrow('must be 0-10');
+            expect(() => (0, attribute_parser_1.parseQualityValue)('11')).toThrow(errors_1.ParseError);
+            expect(() => (0, attribute_parser_1.parseQualityValue)('11')).toThrow('must be 0-10');
+        });
+        it('should throw for invalid quality', () => {
+            expect(() => (0, attribute_parser_1.parseQualityValue)('abc')).toThrow(errors_1.ParseError);
+        });
+    });
+});

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

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

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

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