browser-debugger-cli 0.6.1 → 0.6.4

package/dist/telemetry/har/__tests__/builder.unit.test.js

@@ -0,0 +1,694 @@
+/**
+ * HAR Builder Unit Tests
+ *
+ * Tests the contract of buildHAR function - transforming NetworkRequest[] to HAR 1.2 format.
+ * Following TESTING_PHILOSOPHY.md: Test the contract, not the implementation.
+ */
+import assert from 'node:assert/strict';
+import { describe, test } from 'node:test';
+import { buildHAR } from '../../../telemetry/har/builder.js';
+describe('HAR Builder', () => {
+    const baseMetadata = {
+        version: '0.7.0',
+        chromeVersion: '131.0.0.0',
+    };
+    /**
+     * Helper to get first entry with TypeScript assertion.
+     */
+    function getFirstEntry(entries) {
+        const entry = entries[0];
+        assert.ok(entry, 'Entry should exist');
+        return entry;
+    }
+    /**
+     * Calculate total time from timings (same logic as builder).
+     */
+    function calculateExpectedTotalTime(timings) {
+        const phases = ['blocked', 'dns', 'connect', 'send', 'wait', 'receive'];
+        return phases.reduce((total, phase) => {
+            const time = timings[phase];
+            return total + (time !== undefined && time >= 0 ? time : 0);
+        }, 0);
+    }
+    describe('Basic structure', () => {
+        test('creates valid HAR 1.2 structure', () => {
+            const requests = [];
+            const har = buildHAR(requests, baseMetadata);
+            assert.equal(har.log.version, '1.2');
+            assert.equal(har.log.creator.name, 'bdg');
+            assert.equal(har.log.creator.version, '0.7.0');
+            assert.ok(Array.isArray(har.log.entries));
+        });
+        test('includes browser info when chromeVersion provided', () => {
+            const har = buildHAR([], baseMetadata);
+            assert.ok(har.log.browser);
+            assert.equal(har.log.browser.name, 'Chrome');
+            assert.equal(har.log.browser.version, '131.0.0.0');
+        });
+        test('omits browser info when chromeVersion not provided', () => {
+            const har = buildHAR([], { version: '0.7.0' });
+            assert.equal(har.log.browser, undefined);
+        });
+    });
+    describe('Request transformation', () => {
+        test('transforms basic GET request', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com/api',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            assert.equal(har.log.entries.length, 1);
+            const entry = getFirstEntry(har.log.entries);
+            assert.equal(entry.request.method, 'GET');
+            assert.equal(entry.request.url, 'https://example.com/api');
+            assert.equal(entry.request.httpVersion, 'HTTP/1.1');
+        });
+        test('includes request headers', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    requestHeaders: {
+                        'user-agent': 'test-agent',
+                        accept: 'application/json',
+                    },
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const headers = getFirstEntry(har.log.entries).request.headers;
+            assert.equal(headers.length, 2);
+            assert.ok(headers.some((h) => h.name === 'user-agent' && h.value === 'test-agent'));
+            assert.ok(headers.some((h) => h.name === 'accept' && h.value === 'application/json'));
+        });
+        test('extracts query parameters from URL', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com/api?foo=bar&baz=qux',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const query = getFirstEntry(har.log.entries).request.queryString;
+            assert.equal(query.length, 2);
+            assert.ok(query.some((q) => q.name === 'foo' && q.value === 'bar'));
+            assert.ok(query.some((q) => q.name === 'baz' && q.value === 'qux'));
+        });
+        test('includes POST body', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com/api',
+                    method: 'POST',
+                    timestamp: Date.now(),
+                    requestBody: '{"key":"value"}',
+                    requestHeaders: {
+                        'content-type': 'application/json',
+                    },
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const postData = getFirstEntry(har.log.entries).request.postData;
+            assert.ok(postData);
+            assert.equal(postData.mimeType, 'application/json');
+            assert.equal(postData.text, '{"key":"value"}');
+        });
+        test('calculates request headers size including HTTP line', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com/path',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    requestHeaders: {
+                        host: 'example.com',
+                    },
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const headersSize = getFirstEntry(har.log.entries).request.headersSize;
+            // Should include "GET /path HTTP/1.1\r\n" + "host: example.com\r\n" + "\r\n"
+            assert.ok(headersSize > 0);
+            assert.ok(headersSize > 'host: example.com'.length); // More than just header
+        });
+    });
+    describe('Response transformation', () => {
+        test('includes response status and headers', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    status: 200,
+                    mimeType: 'text/html',
+                    responseHeaders: {
+                        'content-type': 'text/html; charset=utf-8',
+                    },
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const response = getFirstEntry(har.log.entries).response;
+            assert.equal(response.status, 200);
+            assert.equal(response.statusText, 'OK');
+            assert.equal(response.httpVersion, 'HTTP/1.1');
+            assert.ok(response.headers.some((h) => h.name === 'content-type'));
+        });
+        test('includes response body', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    status: 200,
+                    mimeType: 'application/json',
+                    responseBody: '{"result":"ok"}',
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const content = getFirstEntry(har.log.entries).response.content;
+            assert.equal(content.mimeType, 'application/json');
+            assert.equal(content.text, '{"result":"ok"}');
+            assert.ok(content.size > 0);
+        });
+        test('base64 encodes binary content', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com/image.png',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    status: 200,
+                    mimeType: 'image/png',
+                    responseBody: 'binary-data',
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const content = getFirstEntry(har.log.entries).response.content;
+            assert.equal(content.mimeType, 'image/png');
+            assert.equal(content.encoding, 'base64');
+            assert.ok(content.text); // Should be base64 encoded
+        });
+        test('uses encodedDataLength for response bodySize', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    status: 200,
+                    responseBody: 'test',
+                    encodedDataLength: 1234, // Wire size (compressed)
+                    decodedBodyLength: 5678, // Decoded size
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const response = getFirstEntry(har.log.entries).response;
+            assert.equal(response.bodySize, 1234); // Should use wire size
+            assert.equal(response.content.size, 5678); // Should use decoded size
+        });
+        test('calculates response headers size including status line', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    status: 200,
+                    responseHeaders: {
+                        'content-type': 'text/html',
+                    },
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const headersSize = getFirstEntry(har.log.entries).response.headersSize;
+            // Should include "HTTP/1.1 200 OK\r\n" + headers + "\r\n"
+            assert.ok(headersSize > 0);
+            assert.ok(headersSize > 'content-type: text/html'.length);
+        });
+    });
+    describe('Timing calculations', () => {
+        test('uses real timing data when available', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    timing: {
+                        requestTime: 1000.0,
+                        dnsStart: 0,
+                        dnsEnd: 50,
+                        connectStart: 50,
+                        connectEnd: 150,
+                        sslStart: 75,
+                        sslEnd: 125,
+                        sendStart: 150,
+                        sendEnd: 155,
+                        receiveHeadersEnd: 200,
+                    },
+                    loadingFinishedTime: 1000.25, // 250ms after requestTime
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const timings = getFirstEntry(har.log.entries).timings;
+            assert.equal(timings.dns, 50); // dnsEnd - dnsStart
+            assert.equal(timings.connect, 100); // connectEnd - connectStart
+            assert.equal(timings.ssl, 50); // sslEnd - sslStart
+            assert.equal(timings.send, 5); // sendEnd - sendStart
+            assert.equal(timings.wait, 45); // receiveHeadersEnd - sendEnd
+            assert.equal(timings.receive, 50); // (loadingFinishedTime - requestTime)*1000 - receiveHeadersEnd
+        });
+        test('uses -1 for unknown timing fields', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    timing: {
+                        requestTime: 1000.0,
+                        dnsStart: -1,
+                        dnsEnd: -1,
+                        connectStart: -1,
+                        connectEnd: -1,
+                        sendStart: 150,
+                        sendEnd: 155,
+                        receiveHeadersEnd: 200,
+                    },
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const timings = getFirstEntry(har.log.entries).timings;
+            assert.equal(timings.dns, -1);
+            assert.equal(timings.connect, -1);
+            assert.equal(timings.send, 5); // Still calculates known values
+        });
+        test('calculates total time from timing breakdown', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    timing: {
+                        requestTime: 1000.0,
+                        dnsStart: 0,
+                        dnsEnd: 50,
+                        connectStart: 50,
+                        connectEnd: 150,
+                        sendStart: 150,
+                        sendEnd: 155,
+                        receiveHeadersEnd: 200,
+                    },
+                    loadingFinishedTime: 1000.25,
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const { timings, time } = getFirstEntry(har.log.entries);
+            // time should be sum of all phases (except ssl which overlaps)
+            assert.equal(time, calculateExpectedTotalTime(timings));
+        });
+        test('handles missing timing data gracefully', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    // No timing data
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const { timings, time } = getFirstEntry(har.log.entries);
+            assert.equal(timings.blocked, -1);
+            assert.equal(timings.dns, -1);
+            assert.equal(timings.connect, -1);
+            assert.equal(timings.send, -1);
+            assert.equal(timings.wait, -1);
+            assert.equal(timings.receive, -1);
+            assert.equal(time, 0); // No timing data = 0 total
+        });
+    });
+    describe('Server metadata', () => {
+        test('includes server IP and connection ID when available', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    serverIPAddress: '192.168.1.1',
+                    connection: '42',
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const entry = getFirstEntry(har.log.entries);
+            assert.equal(entry.serverIPAddress, '192.168.1.1');
+            assert.equal(entry.connection, '42');
+        });
+        test('omits server metadata when not available', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const entry = getFirstEntry(har.log.entries);
+            assert.equal(entry.serverIPAddress, undefined);
+            assert.equal(entry.connection, undefined);
+        });
+    });
+    describe('Edge cases', () => {
+        test('handles empty request array', () => {
+            const har = buildHAR([], baseMetadata);
+            assert.equal(har.log.entries.length, 0);
+        });
+        test('handles request with no headers', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const { request, response } = getFirstEntry(har.log.entries);
+            assert.equal(request.headers.length, 0);
+            assert.equal(response.headers.length, 0);
+        });
+        test('handles failed request (status 0)', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    status: 0,
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const response = getFirstEntry(har.log.entries).response;
+            assert.equal(response.status, 0);
+            assert.equal(response.statusText, 'Unknown');
+        });
+        test('handles URL with special characters', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com/path?query=hello%20world&foo=bar%26baz',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const entry = getFirstEntry(har.log.entries);
+            assert.equal(entry.request.url, 'https://example.com/path?query=hello%20world&foo=bar%26baz');
+            assert.ok(entry.request.queryString.length > 0);
+        });
+    });
+    describe('Cookie handling', () => {
+        test('extracts cookies from request headers', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    requestHeaders: {
+                        cookie: 'session=abc123; theme=dark',
+                    },
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const cookies = getFirstEntry(har.log.entries).request.cookies;
+            assert.equal(cookies.length, 2);
+            assert.ok(cookies.some((c) => c.name === 'session' && c.value === 'abc123'));
+            assert.ok(cookies.some((c) => c.name === 'theme' && c.value === 'dark'));
+        });
+        test('extracts cookies from set-cookie header', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    responseHeaders: {
+                        'set-cookie': 'session=xyz789; path=/; secure',
+                    },
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const cookies = getFirstEntry(har.log.entries).response.cookies;
+            assert.ok(cookies.length > 0);
+            assert.ok(cookies.some((c) => c.name === 'session'));
+        });
+    });
+    describe('Receive time edge cases', () => {
+        test('handles loadingFinishedTime before receiveHeadersEnd (invalid data)', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    timing: {
+                        requestTime: 1000.0,
+                        receiveHeadersEnd: 200,
+                        sendEnd: 150,
+                        sendStart: 140,
+                        sslEnd: 130,
+                        sslStart: 100,
+                        connectEnd: 100,
+                        connectStart: 50,
+                        dnsEnd: 50,
+                        dnsStart: 0,
+                    },
+                    loadingFinishedTime: 999.9, // Before requestTime (impossible but test robustness)
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const timings = getFirstEntry(har.log.entries).timings;
+            // Should produce negative receive time, which is valid per HAR spec for unknown/invalid
+            // receive = (999.9 - 1000.0) * 1000 - 200 = -100 - 200 = -300
+            // Use approximate comparison for floating point
+            assert.ok(Math.abs(timings.receive - -300) < 0.001, `Expected -300, got ${timings.receive}`);
+        });
+        test('handles large file download (significant receive time)', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com/large-file.zip',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    timing: {
+                        requestTime: 1000.0,
+                        receiveHeadersEnd: 200,
+                        sendEnd: 150,
+                        sendStart: 140,
+                        sslEnd: 130,
+                        sslStart: 100,
+                        connectEnd: 100,
+                        connectStart: 50,
+                        dnsEnd: 50,
+                        dnsStart: 0,
+                    },
+                    loadingFinishedTime: 1005.5, // 5.5 seconds after requestTime
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const timings = getFirstEntry(har.log.entries).timings;
+            // receive = (1005.5 - 1000.0) * 1000 - 200 = 5500 - 200 = 5300ms
+            assert.equal(timings.receive, 5300);
+        });
+        test('handles missing loadingFinishedTime gracefully', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    timing: {
+                        requestTime: 1000.0,
+                        receiveHeadersEnd: 200,
+                        sendEnd: 150,
+                        sendStart: 140,
+                        sslEnd: 130,
+                        sslStart: 100,
+                        connectEnd: 100,
+                        connectStart: 50,
+                        dnsEnd: 50,
+                        dnsStart: 0,
+                    },
+                    // No loadingFinishedTime
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const timings = getFirstEntry(har.log.entries).timings;
+            assert.equal(timings.receive, -1); // Unknown
+        });
+    });
+    describe('Binary content encoding validation', () => {
+        test('base64 encodes binary content correctly', () => {
+            const binaryData = 'test-binary-data';
+            const expectedBase64 = Buffer.from(binaryData).toString('base64');
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com/image.png',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    status: 200,
+                    mimeType: 'image/png',
+                    responseBody: binaryData,
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const content = getFirstEntry(har.log.entries).response.content;
+            assert.equal(content.encoding, 'base64');
+            assert.equal(content.text, expectedBase64);
+        });
+        test('detects various binary MIME types', () => {
+            const binaryTypes = [
+                'image/jpeg',
+                'image/gif',
+                'video/mp4',
+                'audio/mpeg',
+                'application/pdf',
+                'application/zip',
+            ];
+            for (const mimeType of binaryTypes) {
+                const requests = [
+                    {
+                        requestId: 'req-1',
+                        url: 'https://example.com/file',
+                        method: 'GET',
+                        timestamp: Date.now(),
+                        status: 200,
+                        mimeType,
+                        responseBody: 'data',
+                    },
+                ];
+                const har = buildHAR(requests, baseMetadata);
+                const content = getFirstEntry(har.log.entries).response.content;
+                assert.equal(content.encoding, 'base64', `Should base64 encode ${mimeType}`);
+                assert.equal(content.text, Buffer.from('data').toString('base64'));
+            }
+        });
+        test('does not encode text content', () => {
+            const textTypes = ['text/html', 'text/plain', 'application/json', 'application/javascript'];
+            for (const mimeType of textTypes) {
+                const requests = [
+                    {
+                        requestId: 'req-1',
+                        url: 'https://example.com/file',
+                        method: 'GET',
+                        timestamp: Date.now(),
+                        status: 200,
+                        mimeType,
+                        responseBody: '{"test":"data"}',
+                    },
+                ];
+                const har = buildHAR(requests, baseMetadata);
+                const content = getFirstEntry(har.log.entries).response.content;
+                assert.equal(content.encoding, undefined, `Should not encode ${mimeType}`);
+                assert.equal(content.text, '{"test":"data"}');
+            }
+        });
+    });
+    describe('Complex header parsing', () => {
+        test('handles headers with special characters', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    requestHeaders: {
+                        'user-agent': 'Mozilla/5.0 (X11; Linux x86_64)',
+                        'accept-language': 'en-US,en;q=0.9',
+                        'x-custom': 'value=with=equals',
+                    },
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const headers = getFirstEntry(har.log.entries).request.headers;
+            assert.ok(headers.some((h) => h.name === 'user-agent' && h.value.includes('X11')));
+            assert.ok(headers.some((h) => h.name === 'accept-language' && h.value.includes('q=0.9')));
+            assert.ok(headers.some((h) => h.name === 'x-custom' && h.value === 'value=with=equals'));
+        });
+        test('handles empty header values', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    requestHeaders: {
+                        'empty-header': '',
+                        'normal-header': 'value',
+                    },
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const headers = getFirstEntry(har.log.entries).request.headers;
+            assert.ok(headers.some((h) => h.name === 'empty-header' && h.value === ''));
+            assert.ok(headers.some((h) => h.name === 'normal-header' && h.value === 'value'));
+        });
+        test('calculates header size for complex headers', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com/path?query=value',
+                    method: 'POST',
+                    timestamp: Date.now(),
+                    requestHeaders: {
+                        'content-type': 'application/json; charset=utf-8',
+                        authorization: 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
+                        'x-request-id': '550e8400-e29b-41d4-a716-446655440000',
+                    },
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const headersSize = getFirstEntry(har.log.entries).request.headersSize;
+            // Should include: "POST /path?query=value HTTP/1.1\r\n" + all headers + "\r\n"
+            const expectedMinSize = 'POST /path?query=value HTTP/1.1\r\n'.length +
+                'content-type: application/json; charset=utf-8\r\n'.length +
+                'authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9\r\n'.length +
+                'x-request-id: 550e8400-e29b-41d4-a716-446655440000\r\n'.length +
+                '\r\n'.length;
+            assert.ok(headersSize >= expectedMinSize, `Headers size ${headersSize} should be >= ${expectedMinSize}`);
+        });
+        test('handles cookie headers with special characters', () => {
+            const requests = [
+                {
+                    requestId: 'req-1',
+                    url: 'https://example.com',
+                    method: 'GET',
+                    timestamp: Date.now(),
+                    requestHeaders: {
+                        cookie: 'token=abc%3D%3D123; path=/admin; expires=Wed, 21 Oct 2025 07:28:00 GMT',
+                    },
+                },
+            ];
+            const har = buildHAR(requests, baseMetadata);
+            const cookies = getFirstEntry(har.log.entries).request.cookies;
+            // Should parse cookie name/value pairs (ignoring attributes like path, expires)
+            assert.ok(cookies.length >= 1);
+            assert.ok(cookies.some((c) => c.name === 'token'));
+        });
+    });
+});
+//# sourceMappingURL=builder.unit.test.js.map